Blog

  • Your Traffic Number Is Wrong This Month. What to Count Instead

    Your Traffic Number Is Wrong This Month. What to Count Instead

    Three things distorted your traffic number in the last ten days, and none of them was your site getting worse. Google undercounted impressions in its Search Console Generative AI report from 9 to 11 November, the November core update started inside that same gap, and a share of what your analytics calls “direct” was never a person. This month the session graph is a story about measurement, not demand — so read completed actions instead.

    The short version

    • Google confirmed a logging error lowered impressions in the Search Console Generative AI performance report for 9–11 November. The data is missing; the visibility was not.
    • The November 2026 core update started on 10 November and should be finishing around now.
    • Google’s advice is to wait a full week after the rollout completes before comparing anything at all.
    • “Direct” in GA4 is the bucket for traffic with no referrer. It is not a channel and it never was.
    • For the next two weeks, count five completed actions a week and leave the session graph alone.

    What actually broke, in order

    9–11 November: a logging error. Google’s entry on its data anomalies page reads: “A logging error caused a decrease in impressions on the Generative AI performance report in Search for data from November 9 – November 11, 2026. This issue affects data logging only.” That report shows impressions only and no clicks, so the damage is confined to one number on one screen. Annotate those three days in whatever dashboard you keep, because in six months the dip will look like a ranking event.

    10 November: the core update started. Google described it as “a regular update designed to better surface relevant, satisfying content”, global and in all languages, with a rollout of up to two weeks. Glenn Gabe’s running notes put visible movement at around 13 November and kept repeating one thing: Search Console is the source of truth this time, because the visibility tools were struggling and because a wave of “phantom agent clicks” earlier in the month had slipped through Google’s systems. Two measurement systems were wobbling at once.

    10 November, same day: a new counter appeared. OpenAI opened Business Hub in beta, where a business can claim its profile and see, for the past 28 days, how often ChatGPT mentioned it and how many website clicks it sent. Search Engine Journal claimed its own profile and reported 353,356 mentions against 2,663 website clicks for 14 October to 10 November. Look at that ratio. A lot of mentions, a small number of clicks is exactly what being quoted in an AI answer looks like from the inside.

    Late November: the calendar. Thanksgiving, Black Friday and Cyber Monday fall inside the first clean comparison week, so any retail site comparing that week to an ordinary one is comparing two kinds of behaviour, not two versions of its content.

    Why “direct” is not a channel

    GA4 files a session as direct when there is no referrer it recognises. That covers someone typing your domain, a bookmark, an email client that strips the referrer, an RSS reader, a preview bot fetching your page for a link card, and an AI assistant opening your page to answer a question. All of it lands in one column labelled direct, and that column is usually the biggest one on a small site.

    One founder published his own split on Indie Hackers this month: 46 Organic Search sessions against 491 Direct sessions from 25 October to 11 November. He was careful about it in a way I respect — he wrote that he could not point at a day with 79 total sessions and claim SEO brought 79 visitors. The channel pie on a site this size tells you almost nothing: the sample is tiny and the buckets are unreliable.

    So stop optimising the pie. Pick the action that proves a person got value, and count that instead.

    Five completed actions worth counting

    Action What it proves Where to capture it
    A tool run finishes Someone used the thing, not just loaded it One custom event on the result state
    A file download The output left your site Automatic file_download, filtered to real formats
    A form or email reply A human typed something Your inbox, no analytics needed
    A click from a post to your paid page Intent survived the read One event on that link
    A second visit within seven days Habit, not a one-off A user-scoped exploration

    Two are enough for a one-person site: the tool-run event and the form submission, because one measures the product and the other measures the person. If your site is a blog, swap the first row for “read to the end of a post” — an event at 90 per cent scroll depth separates a reader from a bounce in a way average engagement time never does.

    A ten-minute Monday log

    The reason a bad week confuses you is that you compare it to a number you half-remember. Keep the number somewhere you can see it, in the same shape every week:

    week:        2026-11-16 .. 2026-11-22
    core update: in progress / finished
    tool runs:   ___
    downloads:   ___
    forms:       ___
    GSC clicks:  ___
    one line:    what changed, and the reason I think so

    Five numbers and one sentence, ten minutes a week. Six weeks of it tells you more than any dashboard, because the sentence forces you to write down the cause instead of guessing later.

    Once a month, also check how much of your server log is agents rather than people. On a Plesk server the access log sits at /var/www/vhosts/<domain>/logs/proxy_access_ssl_log; on cPanel look under ~/logs. This counts the crawler families that matter by name:

    grep -Eio 'gptbot|oai-searchbot|chatgpt-user|claudebot|perplexitybot|ccbot|google-extended' access.log | sort | uniq -c | sort -rn

    A training crawler reading every post is a cost. A search crawler indexing your tool pages is the reason anyone finds them at all. A user-triggered fetch — ChatGPT-User or Perplexity-User — is a person on the other end of a question, and it is the one kind of agent traffic that can turn into a sale.

    What to ignore until the rollout ends

    • Title rewrites. Mid-rollout you cannot tell whether a change helped or the update did.
    • Deleting pages after a three-day dip. Three days of a two-week rollout is noise, and a deletion is permanent.
    • Week-over-week comparisons that straddle 9 November. One analysis of the anomalies page suggests comparing 14 days before 9 November with 14 days after 11 November instead, and using main-report clicks as the steadier signal.
    • “We lost 40 per cent of AI impressions” taken from the Generative AI report. That report counts impressions only, and it was undercounting for three of those days.

    None of this is a reason to stop working, only to stop reacting for two weeks. The pages still need writing; you just cannot grade them yet.

    Checklist for the next two weeks

    • Annotate 9–11 November on every dashboard you keep.
    • Write down today’s tool runs, downloads and form counts, so next Monday has a baseline.
    • Check that your analytics fires one completion event, and that it survives a bot visit — most do not.
    • Run the log filter once and note the agent share. That number explains a lot of “direct”.
    • If you run a real business, claim your ChatGPT business profile and screenshot the 28-day baseline.
    • Set a reminder for one week after Google marks the rollout complete, not before.

    The update will finish, the logging gap will close or it will not, and the session graph will go back to being roughly true. What survives is the habit of measuring the five things only a person can do on your site. That habit works in a quiet month and in a month like this one, when every number moved for reasons that had nothing to do with you.

    For the other half — why a page can be indexed and still never rank — see 88 tools, 8 organic sessions. And if you have not yet decided which crawlers you are letting in, the file agents read before they touch your site is the place to start. The core update itself I covered the week it began, in what to do while it rolls out.

  • 88 Tools, 8 Organic Sessions: What Actually Pulls a Tool Site Into Search

    88 Tools, 8 Organic Sessions: What Actually Pulls a Tool Site Into Search

    Three field reports landed on Indie Hackers this week, and none of them was about a traffic tactic. One developer shipped 88 browser tools and search sent him 8 sessions in thirty days. Another published about 6,500 pages in two weeks and watched his impressions fall to zero, including for his own brand name. A third went from 48 to 166 Google clicks in 28 days without writing more guides.

    Read together, they answer a question I have been avoiding about my own free PDF tools site: I keep adding tools and calling it marketing. The pages are the problem, not the count.

    The short version

    • A tool page is a form, not a document. If the HTML that arrives carries 80 words of interface labels, there is nothing for a search engine to match.
    • Page count is not authority. Thousands of thin pages can suppress a whole domain, brand query included.
    • The pages that move have something only their owner can publish: real data, real tests, real screenshots.
    • Retitle from queries you already appear for. Search Console is a list of words people actually used, not a keyword tool.
    • Fix the crawl layer before writing anything new: duplicate URLs, overlong titles, pages that render empty.

    Three numbers from one week

    Site What the owner did What happened
    handytk.com Built 88 browser tools, each with its own title and keywords 281 sessions from direct traffic, 8 from organic search; one tool page got 6 views
    calcbloc.com Published roughly 6,500 programmatic tax pages in two weeks Impressions went to zero, brand name included; he noindexed all 6,500
    batteryhealthlab.com Published one page of real battery data, retitled pages to match queries, cleaned up the crawl Clicks 48 to 166, impressions 7.46k to 21.8k in 28 days

    The first row is the one I recognise. handytk.com had 270 active users, 381 page views and 1.3K events over thirty days; 281 sessions came from people who typed the domain, eight from search. He had written titles for “SVG to PNG” and “PDF merge”, the phrases the established tools own, and Google sent almost nobody.

    His own diagnosis is worth repeating: the homepage and the blog got more traffic than any tool page. People were curious about the project, then left without using the thing it exists for.

    Why a tool page has nothing to rank with

    A tool page has a structural handicap that a blog post does not: the useful part is behaviour, not text. The page says “Select file”, “Merge”, “Download”. Everything that answers a query — what it does, when to use it, what it costs you in privacy, what it does badly — is missing because the tool works, so nobody writes it.

    Then add rendering. If the tool is a client-side app, the HTML the crawler receives first can be an empty shell with a title and a bundle tag. Google can execute JavaScript, but on a budget and on its own schedule. A page whose text only appears after JavaScript has to earn that second pass. Most tool pages never do.

    That is my own site’s problem. My free PDF tools at pdffold.com run entirely in the browser, which is the honest selling point and also why most of what a visitor sees is drawn by JavaScript. I built the tools and assumed the pages would be found because they existed. The 88-tool report is what that assumption looks like when measured.

    What the site that climbed actually changed

    The battery site is the useful counter-example because the changes were small and none of them was “publish more guides”. Four moves, in his own account:

    He published something nobody else had. Battery reports from four real laptops — his own two, his sister’s Lenovo, his brother’s HP — with a chart and a downloadable CSV, including the odd values: a battery that tripled for a day, 67 years of AC time in a week, a cycle count that was just a dash. That page could not have been written by anyone with a keyword list.

    He retitled pages to match real queries. Search Console showed impressions for phrases his titles did not answer, so “Battery Health Percentage” became “How to Calculate Laptop Battery Health: Formula + Calculator”, and he added a page for an exact error message people were searching, because the report saves somewhere they cannot find.

    He fixed the boring layer. A crawl found titles and descriptions that were too long, the tools index reachable at two URLs, and a broken link. None of that is exciting. All of it was real.

    The caveat matters: after 28 days the data page itself was still “crawled, currently not indexed”, and AdSense had rejected the site three times for low value content. The clicks came from the cluster around the data, not from that page ranking. This is a slow repair, not a switch.

    What I am doing to my own tools site

    In order, because the order matters. Fixing the crawl layer after writing new pages wastes the new pages.

    1. Find out what actually arrives. Fetch a tool page the way a crawler does and count the words in the HTML. Under about 150 and there is nothing to index; everything else is decoration.

    curl -sL "https://your-site.com/tool/" \
      | sed -e 's/<[^>]*>/ /g' \
      | tr -s ' \n' ' ' \
      | wc -w

    2. Make the page arrive with text. For my site that means pre-rendering each tool page to static HTML at build time: heading, the job explained, limitations, privacy note, and the output of a sample run. Same tool, same interface, but the first response is a document.

    3. Pick one page to be the original-data page. Not a new tool. One page of measurements I can run: how much a PDF shrinks at each compression level, how long a 200-page merge takes in a browser tab, which files break. Nobody else has those numbers.

    4. Rewrite titles from Search Console, not from imagination. Whatever query already gets impressions is the language to use. Impressions without clicks mean the title is not answering that query.

    5. Collapse duplicate URLs. Trailing-slash variants, parameters, print views, the tools index at two addresses. One canonical per page, one sitemap entry.

    6. Point the writing at the tools. The 88-tool case shows blog posts outrunning tool pages. Not a reason to stop writing; a reason to write the post that ends with the tool. “How to merge PDFs without uploading them” is a page someone searches for, and it has somewhere to send them.

    The one-page test before you build tool 89

    If you already run a tools site, run this on a single page this week instead of starting another tool:

    • Does the raw HTML contain at least 150 words about the job, in the response, before JavaScript runs?
    • Does the title use the words someone would type, in their order?
    • Is there one thing on the page that no competitor can copy without doing the work — measurements, screenshots, failure cases?
    • Does the page link to the two pages most related to it, and do those pages link back?
    • Can it be reached at exactly one URL?

    Five yeses on one page beats eighty-eight pages of “Select file”.

    This is client work too

    When a small business asks why the site is not ranking, the reflex is “add more pages”. The three reports point the other way: fewer pages, each carrying something real, plus a crawl that is not fighting itself — a conversation I can defend with a Search Console screenshot instead of a promise.

    What I am doing this week

    One page: my merge tool, static HTML with 300 words on what merging in a browser does to file structure, one table of measured times from real documents, and links to two guides that already exist. Then I will wait 28 days and look at impressions, the way the battery site did, instead of adding tool number 89 and hoping.

    Two prerequisites: connect Search Console before you touch a title, because a retitle without query data is guessing in a different font, and if a core update is rolling, do not read a bad week as a verdict. Then plan the writing with the one-afternoon plan I use.

  • Contact Form 7’s Upload Bug Goes Public Today. Check Your Version First

    Contact Form 7’s Upload Bug Goes Public Today. Check Your Version First

    If your site runs Contact Form 7, open the Plugins screen and read the version number before you do anything else today. Anything from 6.2 to 6.2.3 lets an unauthenticated visitor leave a file on your server, and a demonstration of how to do it is due to be published today, 19 November. Version 6.2.4 closed that hole on 29 October. Version 6.2.5, released on Tuesday, closed two smaller leaks on top of it. That is the whole decision: you are on 6.2.5, or you have an hour of work this morning.

    The short version

    • Affected versions: 6.2 through 6.2.3. Fixed in 6.2.4. Best available now: 6.2.5.
    • The bug needs no account and no login. Any visitor who can reach a form with a file upload field can use it.
    • On a stock Debian or Ubuntu Apache server, that file can be found and run as code. On nginx and on most managed hosts it is “only” an arbitrary file inside wp-content/uploads, which still means an HTML or SVG page served from your own domain.
    • 6.2.4 got stricter about file names. Any form that accepts uploads needs to be tested after you update.
    • If you cannot update within the hour, close directory listing and block PHP execution in the uploads folder today. That is a ten-line file, and it buys you time.

    What the bug actually does

    Two failures stack. The plugin does not check the type or extension of a file going through a form’s file field, and a flaw in its temporary-file cleanup means the upload is not removed when the submission finishes. Together, an unauthenticated request can park a file of its choosing on disk and leave it there.

    The specific trick that made it work is in the file name: an invalid UTF-8 sequence in the name slips past a check that expects a valid string, which is where the published title comes from. The researcher credited is Shinya Murakami, and the vulnerability is catalogued as CVE 2026-114432.

    None of this needs knowledge of your site, only a form with an upload field — which is what a quote form, an invoice form or a “send us your CV” form is.

    Where it stops being a plumbing problem

    A stray file in a folder sounds survivable. It stops being survivable when the server agrees to interpret it, and that depends on configuration you probably did not write.

    On a stock Debian or Ubuntu Apache setup, two defaults line up badly: the server lists directory contents, and it maps .phar to the PHP handler. An uploaded file with that extension can be browsed to by name and executed, which turns a form field into remote code execution on the account that runs your WordPress site.

    On nginx, and on Apache installs where .htaccess overrides are switched off, the same file cannot be executed. It is still served as active content from your own origin: an HTML or SVG page you did not publish, hosted under your name, passing every “is this our domain” check a visitor or mail filter might make. The gap between those outcomes is your host’s configuration, not your code.

    Check the version in one command

    With WP-CLI it is one line:

    wp plugin get contact-form-7 --fields=name,status,version
    
    # and, if you want to see everything else waiting for you
    wp plugin list --update=available

    Without WP-CLI: Plugins → Installed Plugins, find Contact Form 7, read the version under the name. If the number is 6.2, 6.2.1, 6.2.2 or 6.2.3, stop reading and update.

    If you cannot update today

    Create or edit wp-content/uploads/.htaccess and put this in it:

    Options -Indexes
    
    <FilesMatch "\.(php|phtml|phar|php[0-9])$">
      Require all denied
    </FilesMatch>

    That closes the two conditions that turn an upload into code execution on Apache: the folder no longer lists itself, and the server refuses to hand a PHP-family file to the interpreter. It does not fix the bug. Files can still land in the folder; they just cannot run.

    On nginx this file does nothing at all, because nginx does not read .htaccess. There you need a location block in the server config, which means a message to your host. Ask for two things in the same message: block execution of PHP files inside the uploads directory, and tell you which PHP branch you are on, because a critical PHP security release is being published today as well.

    Where you stand, in one table

    Your version What it means today What to do
    6.2.5 Current. Both leaks closed. Nothing today. If you jumped here from 6.2.3, retest your upload forms.
    6.2.4 Upload hole closed. Two smaller leaks open. Update to 6.2.5 today.
    6.2 – 6.2.3 Publicly attackable, with a walkthrough due today. Update now, then read the uploads folder for files you did not put there.
    No idea Exposure is unknown, which is worse than known. Read the number now, then harden uploads while you arrange the update.

    The two leaks in 6.2.5 nobody is talking about

    6.2.5 does not fix the upload bug; it fixes two smaller ones: mail tags and default values could reveal private post data or user details. If a form’s mail template references post data, or a default value resolves against something the visitor should not see, the response carries it out.

    That is quieter than an arbitrary upload and easy to skip because nothing is on fire. What makes it worth the update is how little it needs: no invalid UTF-8, no server configuration, no extension games. A form, a tag, a request.

    What I would do in the next hour

    1. Read the version. One command or one screen. Everything below depends on the answer.
    2. Back up and update to 6.2.5. A backup before a plugin update is a thirty-second habit that occasionally saves a weekend.
    3. Submit a test file through every form with an upload field. 6.2.4 made file names stricter, so a form that once accepted an odd name may now reject it, quietly. Test with a normal name and an odd one.
    4. List the uploads folder by date. Look at the newest files. Anything that is not an image or a PDF you recognise is worth opening in a text editor rather than a browser.
    5. Ask whether the folder lists itself. Browse to a known uploads subfolder. If you get a file list instead of a 403 or 404, your host is one of the configurations where an upload can become code execution.
    6. Put the .htaccess above in place even if you updated. It costs nothing, does not touch images, and decides whether the next upload bug is a nuisance or an incident.

    Two unrelated things land this week and get confused with each other. PHP 8.6.0 is released today, and the PHP team is publishing a security release in the same 30-minute window that touches every supported branch. That one is not about plugin versions; it is about which PHP branch your host runs, and I covered the decision and the checks separately, because the answer there is usually “wait” and the answer here is “today”.

    If the version turns out to be 6.2.3 and the site has been live for a month, updating is the start of the job, not the end. Unrecognised files in uploads, a new administrator account, an outgoing mail spike — that is a different checklist, and the five-minute infection check covers the order to look in. I would run it after the update, not before, so you are not reading a live attack while the door is still open.

    The pattern to remember: plugin security releases are announced, details go public weeks later, and the gap between those two dates is your only window. Updating core without opening an attack window is the same lesson from a different angle — the update is not the risk, the delay is.

    The action

    Open the Plugins screen. If Contact Form 7 says 6.2.5, close the tab and get on with your day. If it says anything lower, update it, then spend ten minutes on the uploads folder: what is in it, whether it lists itself, and whether your host will block a .phar from running there. Today is the day those questions stop being theoretical.

  • WordPress 7.2 Encrypts API Keys on 8 December. Where Yours Live Until Then

    WordPress 7.2 Encrypts API Keys on 8 December. Where Yours Live Until Then

    If your WordPress site uses a newsletter plugin, an AI writing tool, or anything that talks to an outside service, that service’s API key is almost certainly sitting in your database as plain text. WordPress has never had a place to put credentials, so every plugin that needed one wrote it into the options table like any other setting. WordPress 7.2, whose first release candidate landed on 17 November and which ships on 8 December, finally adds an encrypted Secrets API. It migrates nothing, and on most existing sites it is switched off until you add one constant to wp-config.php.

    The short version:

    • Plugin API keys today live in wp_options as plain text, so every database backup and every staging clone carries them.
    • 7.2 adds wp_set_secret(), wp_get_secret(), wp_delete_secret() and wp_retire_secret_version(), encrypted at rest with a key that comes from WP_SECRETS_KEY.
    • No WP_SECRETS_KEY, no API. Calls return secret_key_unavailable, and upgraded sites do not get a key automatically.
    • Core does not call the Secrets API yet, so 8 December breaks nothing. The breakage comes later, when the plugins you already use move their keys and your site has no key to encrypt them with.
    • Your work this month is small: find out which plugins hold keys, decide where the encryption key lives, and rotate anything that has been sitting in a backup for years.

    Where your keys are sitting right now

    Almost every settings page you have ever filled in on a WordPress site ends up as one row in wp_options. A plugin stores an array of its settings, and the API key is one string inside that array. There is no masking, no encryption, and no warning. If you have ever restored a site from a backup, sent a database dump to a developer, or cloned production to staging, those keys travelled with it.

    You can see the shape of it with WP-CLI. Run this on a staging copy, not on production during the day, and keep the output to yourself:

    wp db query "SELECT option_name, LENGTH(option_value) AS len
      FROM wp_options
      WHERE option_value REGEXP '(sk-|api[_-]?key|api[_-]?token|secret)'
      ORDER BY len DESC LIMIT 40;"

    That is a blunt search and it will miss keys stored under names that do not mention them, so treat the empty result as inconclusive. The reliable way is to list the plugins you pay for or connect, then open each one’s settings page in the admin and look for a field that holds a token: payment gateways, email providers, SEO tools, AI writing assistants, form-to-CRM connectors, backup services. Every one of those is a key in the database.

    Two more places worth checking: wp-config.php for keys someone hardcoded by hand, and any custom code in the theme that calls an API. Hardcoding in wp-config.php is not encryption either, but at least the file lives outside the database and does not travel with a dump.

    What 7.2 actually gives you

    The API is deliberately plain. A secret has a name in the form plugin-slug/secret-name, and you get it back as a WP_Secret object that stays masked until you call reveal(). Saving, reading and deleting look like this:

    $secret = wp_get_secret( 'my-plugin/api-key' );
    if ( is_wp_error( $secret ) ) {
        // The secret exists but cannot be read.
        return '';
    }
    $key = $secret ? $secret->reveal() : '';

    Three details matter more than the function names. First, secrets are encrypted at rest with a key kept in wp-config.php, not in the database, so a stolen dump is no longer a list of live credentials. Second, the API keeps a previous version of each secret, which makes rotation a two-step operation instead of an outage: write the new key, then retire the old one. Third, a host can swap the storage layer through a secrets.php drop-in, so a host that already runs a secrets manager can keep using it.

    There is no admin screen for secrets in 7.2. That is planned for later, so for now this is a developer-facing change. If you are not writing plugin code, the only part you control is the key.

    The missing key is the real story

    Beta 5 removed the salt fallback. Without WP_SECRETS_KEY the API is simply unavailable. And only the browser installer writes the constant: new sites created through the WordPress installer get one, while upgraded sites get nothing. Neither does a site whose wp-config.php was written by wp config create, a one-click installer or a provisioning script that copies the sample file and fills in only the eight salts. If the placeholder stays in place, the API rejects it.

    Core does not call the API in 7.2, and most plugin authors will wait a release or two before moving their keys, so an upgraded site without a key keeps working for now. What you have is a window: the months between now and the first plugin that moves its key are when you can fix this calmly instead of during a support ticket.

    Check both answers on a staging site:

    wp config has WP_SECRETS_KEY
    wp eval 'var_dump( wp_is_secrets_api_available() );'

    Who has to do what

    If you are Do this before 8 December
    A site owner List the plugins that hold tokens, rotate the important ones, and ask your host whether new sites get a key.
    A plugin author Test the API against RC1, handle secret_key_unavailable, and keep your own option as a fallback until you are sure the key exists.
    A host Write a key in every provisioning path, never regenerate it on a rebuild, and check that secrets do not land in the object cache.

    Rules for the key itself

    Treat WP_SECRETS_KEY like a salt with consequences. Generate it with openssl rand -base64 32, and be careful where the value comes from: a trailing newline from a file makes a different key, a copied salt is rejected, and the placeholder in the sample config is rejected too. Keep it in your password manager next to the database credentials, because if you lose it you lose the ability to decrypt every secret stored with it.

    One key per environment. A key shared across environments means a production database cloned to staging can still read its secrets, which defeats part of the point. A different key means the clone cannot read them at all, and Site Health will show two critical items until you fix it. Either way, decide on purpose rather than by accident. If you rotate the constant itself, put the old value in WP_SECRETS_KEY_PREVIOUS so existing secrets can still be read while you re-save them.

    This is the same class of work as a core update: boring, fifteen minutes, and much cheaper now than after an incident. If you already have a routine for updating WordPress core without opening an attack window, put the key check in the same runbook. If you let an AI agent touch your WordPress site, it matters twice as much, because an agent holding a database-level credential is holding every key in that database.

    What I am doing this week

    1. List every plugin on the site that asks for a token, and write down which ones I would have to fix by hand if the key stopped working.
    2. Run the options query on a staging copy and match the option names to that list.
    3. Rotate the keys that touch money and email first, while the old ones still work and I can compare behaviour.
    4. Ask the host whether a new site gets WP_SECRETS_KEY, and test the answer on a throwaway install rather than trusting the support page.
    5. Try the RC1 on staging with WP-CLI, then check Site Health on both a fresh install and an upgraded one, because they will not behave the same.

    The encryption only protects keys written after it is switched on. Nothing in 7.2 goes back and encrypts the strings already sitting in your options table, and no plugin can do that for you until it adopts the API. So the useful deadline is not 8 December. It is today, and the first command is the query above.

  • remove.bg Closes on 1 December. A Migration Checklist for Small Sites

    remove.bg Closes on 1 December. A Migration Checklist for Small Sites

    remove.bg stops being a standalone product on 1 December 2026 at 09:00 CET. The website and accounts are gone, the self-service API stops accepting requests, unused pay-as-you-go credits expire, and the Photoshop plugin and the other integrations are discontinued. Background removal is not disappearing — it moves into Canva, and the API moves to Leonardo.Ai — but the thing you built your workflow around does.

    If you remove a background once a week, this is a fifteen-minute job. If your product calls the API, it is a week of testing: new credentials, a lower standard rate limit, and a different billing model.

    The short version

    • The site and accounts close on 1 December, 09:00 CET. Subscriptions end on their own; annual plans get unused time refunded pro rata.
    • Pay-as-you-go credits expire with no refund. Spend them first. Export your invoices and credit usage report while you still can download them.
    • The API moves to Leonardo.Ai. Your remove.bg credentials do not carry over, so you create an account and a new key.
    • The standard rate limit drops from 500 images per minute to 100, and billing changes from one credit per image to a USD credit balance that varies by capability.
    • On Canva, Background Remover is paid-plan only: up to 50 images per folder, one folder at a time; free users get a limited number of HD downloads.

    What ends, and what you should do about it

    remove.bg has been part of Canva since 2021. Its homepage, pricing page and FAQ all carry the same banner: the standalone site is gone after 1 December. What matters is which row you are in.

    If you… On 1 December Do this before then
    Use the site now and then Canva’s Background Remover, paid plans only Use the free HD trial, then decide on a plan
    Pay monthly Ends; a final renewal on or after 1 November is free Cancel earlier if you want it to stop sooner
    Pay annually Ends; unused time refunded pro rata Nothing to do; check the refund arrives
    Hold pay-as-you-go credits Expire, no refund Spend the balance on the backlog you keep postponing
    Call the self-service API Stops accepting requests Open a Leonardo.Ai account, issue a new key, retest
    Use the plugin or another integration Discontinued Photoshop, Figma and PowerPoint have their own remover

    The twenty-minute version for everyone else

    Most people do not need a project plan. They need to stop losing things that cannot be recovered afterwards.

    1. Export the paperwork. Invoices and the credit usage report are downloadable from the account page today and not after the shutdown. If you expense this tool, do it now.
    2. Spend the credits. Run every half-finished product shot, headshot and thumbnail through while the account works. Future-you will not remember the credits were about to vanish.
    3. Test a replacement on your hard images. Every remover looks clever on a clean studio photo. Test the three that break them: hair, transparent or mesh fabric, and a product edge against a similar-coloured background.
    4. Keep private images local if that matters. Several browser-based removers that run the model on your machine, with no upload, launched on Show HN this month. For client material under an NDA, on-device processing is the difference between usable and not.
    5. Update your own instructions. Bookmarks, the checklist in your notes app, the “how we prepare images” line in a client document. A dead link in your own process costs more than the tool did.

    If your product calls the API, this is the real work

    The endpoint move is the small part. Start by finding every place you talk to it, because abandoned call sites are how you discover a problem three weeks after launch.

    # every call site in the repo
    grep -rn "api.remove.bg" . --include="*.js" --include="*.php" --include="*.py"
    
    # credentials and config that must move, not the code around them
    grep -rn "REMOVE_BG\|removebg" . --include="*.env*" --include="*.yml" --include="*.json"

    Then work through the differences that will actually break something:

    • New account, new key. remove.bg credentials do not carry over. The change belongs in configuration, not logic, which is why the endpoint and key should live in one adapter function and one config value.
    • Rate limit. remove.bg allows up to 500 images per minute; Leonardo’s standard limit is 100, with higher limits on request. A batch job that fired everything at once will now start returning errors, so add a queue and backoff before you notice it in production.
    • Billing shape. One remove.bg credit meant one image. Leonardo bills in USD from a prepaid balance, and the rate depends on which capability you call. If you resell image processing at a fixed price, redo that arithmetic.
    • Plan coverage. Background removal is not included in Leonardo’s unlimited web plans, and API access is separate from the web subscription. A web plan is not a substitute for API credits.
    • What does not change. Both APIs are synchronous, both accept a file upload or an image URL, and neither stores your images. That part of your code stays as it is.

    What this teaches anyone running a free tool

    The obvious lesson is that a free tool you do not control can end on a date you do not choose. The useful lesson is about where the demand goes when it does.

    When a tool this well known closes, search demand for “remove.bg alternative” does not trickle — it spikes, with a deadline attached. The pages that win it are not listicles with eleven logos. They answer the dated questions: what ends on which day, what happens to my credits, which replacement does bulk, what breaks in my integration. remove.bg’s notice is a banner; the specifics are spread across an FAQ, a help-centre article, a vendor post and a terms update. Someone has to put them on one page with dates, and that someone can be a small site.

    Which is the honest version of the strategy: publish the thing only you will bother to publish. A single-person site cannot beat a platform on features or on price, but it can be the clearest page on the internet about one dated change, and it can keep it current. That is also what keeps a page worth linking to after the deadline passes — the migration is over, the record stays.

    Two cautions. The gap is real but crowded: this shutdown has already produced a wave of alternative pages from free browser removers, many of them decent, some of them thin. If your page is the same list as everyone else’s, you are not filling the gap, you are adding to the noise. And do not let one vendor own your product. One function that takes an image and returns a cutout, an endpoint in configuration, a tested fallback, and a note of the date on which your provider could disappear.

    The five checks I would run this week

    1. List every tool in my stack that depends on a single third-party API, and note which ones I could not replace in a day.
    2. For each one, does the endpoint live in configuration or scattered through the code?
    3. Does each have a tested second option — not a bookmark, a tested option?
    4. Do I have a page that answers “this tool is closing” for my own niche before the news hits? The deadline is the best traffic a small site gets for free.
    5. Is there a path that removes the dependency entirely? For background removal that is on-device processing; for other tools it may be a script I run locally.

    So do the boring part today: open the account page, export the invoices and the usage report, spend the credits on the backlog, and pick your replacement before 1 December rather than the morning you need it. If you run a small site, write the migration page while the searches are happening. Judge it with a clear head: Google’s November core update is still rolling out, so the week you publish is not a fair baseline, and the queries are worth checking in Search Console rather than guessing.

    The tools that end on a schedule are also a reminder of the opposite: a page you publish on your own domain does not send you a shutdown notice.

  • AI Agents Now Ask Your Site for Permission. The File They Read First

    AI Agents Now Ask Your Site for Permission. The File They Read First

    Sierra published version 1.0 of Personal Agent Protocol on 13 November, and the distribution attached to it is the part worth your attention: every Shopify store now publishes the protocol’s discovery file automatically, and Meta’s Muse agent looks for that file first on every site it visits. The file sits at /.well-known/poppy.json, and it is not a sitemap, a feed, or an SEO trick.

    It answers a question your site has never been asked before: an AI agent has arrived on behalf of a customer, and what is it allowed to do here?

    I run two sites that sell nothing through a cart, and I still looked. The moment an assistant can transact for a person, “can this be read by a machine” stops being an SEO question and becomes an access-control question.

    The short version

    • Poppy is an open protocol (Apache 2.0) for how a personal AI agent identifies itself to a company and asks what it may do.
    • The company answers with one file at /.well-known/poppy.json, listing channels, capabilities and sign-in options.
    • Shopify turned it on for every merchant with no opt-in, so the file is already live on millions of stores.
    • It does not move money or change checkout. That still belongs to Universal Commerce Protocol (UCP).
    • The spec is released as 1.0 but still labelled draft, so treat it as a moving target and do not build a business on it yet.

    What Poppy actually is

    Poppy is short for Personal Agent Protocol. It is the handshake that happens before anything else, and it has three parts that matter to a site owner.

    Discovery. A company publishes the JSON file at a fixed path. The file names the company, lists the ways an agent can reach it (an API described by OpenAPI or MCP, the company’s own agent, or plain web browsing), and lists the OAuth scopes an agent may request. Sierra built it on existing standards rather than inventing new ones, which is why the file is short and boring.

    Sessions. When an agent visits, it sends a signed Session header identifying itself and a pseudonymous customer ID. According to the specification, that ID is stable at your company but different at every other company, so you can recognise a returning agent customer without ever learning who they are. That is a better privacy story than most tracking scripts on your site right now.

    Sign-in. If a task needs the customer’s account, standard OAuth handles it. The customer signs in on your page and grants specific scopes, or the agent shows a link and a code they open on another device. The agent never holds the password, and access can be revoked.

    The clever part is the scope_hints block. Each scope can be tagged as changing nothing, making a reversible change, or being irreversible, and as touching personal data. An agent reading it knows which actions must interrupt the customer for a yes.

    What the file looks like

    Here is the shape of a Shopify-served file, trimmed to the parts that matter:

    {
      "protocol_version": "0.4",
      "organization": { "name": "Your Store", "domain": "www.yourstore.com" },
      "auth": {
        "scopes": {
          "dev.ucp.shopping.checkout:manage":
            "Lets the agent prepare checkouts as the signed-in customer."
        },
        "scope_hints": {
          "dev.ucp.shopping.checkout:manage": {
            "changes": "irreversible",
            "personal_data": true
          }
        }
      },
      "agent": {
        "protocols": [
          { "type": "ucp", "endpoint": "https://www.yourstore.com/.well-known/ucp" }
        ]
      },
      "web": {},
      "extensions": { "ucp": [{ "version": "1" }] }
    }

    Notice what is missing: no product data, no prices, no stock. Everything commercial lives in the UCP profile it points at. And the version in Shopify’s file was still 0.4 on 14 November, the day 1.0 shipped.

    What it does not do

    This is where I would push back on the launch-week enthusiasm.

    • It does not handle payments. Sierra’s roadmap lists payments, push notifications and attachments as open. Checkout stays with UCP.
    • It does not enforce anything by itself. The spec includes a web.disabled flag to ask agents not to browse your site, and says plainly that this is not enforceable. It is a polite request, not a wall.
    • It is not a finished standard. Sierra calls it 1.0 while the specification and implementation kit still label the document draft 1.0, permitted to change in ways that are not backward compatible.
    • It is not evidence that agents are already shopping for you. Distribution is real: more than 175 countries on Shopify, and Muse, which The Next Web reports has passed ten million people who set it up. But an agent that can discover your store is not an agent that will show up tomorrow.

    There is also a version gap worth knowing about if you run a store. One index that scanned 129 Shopify retailers on 14 November found the file on 104 of them, all declaring 0.4. The 1.0 spec makes a description field mandatory on every entry under agent.protocols, and the Shopify files do not have one. An agent built strictly to 1.0 may read those files and find nothing it trusts. The same scan found 13 of 14 custom, headless storefronts returning a 404. If you pay someone for a headless build, that is a question to send them this week.

    If you sell on Shopify, check four things

    Check Where What a bad answer means
    The file exists https://yourdomain/.well-known/poppy.json 404 on a Shopify Online Store means the theme or domain is not what you think it is.
    The domain matches organization.domain in the file A file that names a different host cannot speak for your domain.
    The UCP profile resolves /.well-known/ucp Poppy is only pointing at something broken, and the agent has no store to shop.
    Your policies are machine-readable Returns, shipping, contact page An agent quoting an outdated return policy to a customer is your problem, not its.

    If you run a WordPress site with nothing to sell

    Then you have no file to publish and no reason to rush. The kit lets any company implement Poppy itself, but I would not hand-roll that on a client site for a protocol still labelled draft. Watch it for a quarter.

    What you can do now is decide, deliberately, what machine traffic your site welcomes. Two things I did on my own sites after reading the spec:

    Write the policy down. Whether you want AI crawlers reading your pages is a business decision, not a plugin toggle. If agent traffic might bring customers, do not block it, and say plainly on the page what you do and who you serve. If you do not want it, block it on purpose and remember robots.txt is a request, not an enforcement mechanism.

    Read your own access log. An agent arriving with an identifying header looks different from a scraper that pretends to be Chrome. I keep a rolling habit of scanning for unfamiliar user agents, and it is the same muscle I wrote about in how to read access logs and spot a brute-force attack. New agents will show up there before they show up in your analytics, because most analytics tools either drop them or file them under “direct”.

    This is the mirror image of what to let an AI agent touch in your WordPress admin. That was outbound, an agent holding your credentials. This is inbound, an agent holding someone else’s. Same question, opposite direction: decide the permissions yourself, in writing, before you need them.

    What I would do this week

    1. If you run a Shopify Online Store, open your poppy.json and your /.well-known/ucp today. Five minutes, and it tells you whether your store is legible to the agent layer at all.
    2. If you run a headless storefront, test both paths on the customer-facing domain, not the admin one.
    3. If you run any other kind of site, write one sentence on your position on AI crawlers and put it where you will find it. Mine: reading is fine, quoting with attribution is fine, anything needing an account asks first.
    4. Check that the policy page an agent would quote actually matches what you do in practice.

    The uncomfortable part is that a protocol file is now a public statement about your business, in a format no customer reads but every agent does. The comfortable part is that it is still yours to write. Assume the first version will be wrong in a way that only shows up in the logs.

  • WordPress.com Gave Every Paid Plan a Shell. Your First Hour With WP-CLI

    WordPress.com Gave Every Paid Plan a Shell. Your First Hour With WP-CLI

    On 13 November 2026, WordPress.com moved SSH, SFTP, WP-CLI, Git commands and GitHub deployments out of its top-tier plans and onto every paid plan. If you pay for Personal or Premium, you now have a shell on the server that serves your site. The practical effect is narrower and more useful than the announcement sounds: when a plugin breaks your site, you can turn it off in about ten seconds instead of filing a ticket and waiting for someone else to do it.

    Here is the order I use on a fresh shell: what to check before typing anything, the read-only commands that give you a baseline, and the three that can erase weeks of work. Only one of those three asks for confirmation.

    The short version

    • SSH, WP-CLI, Git and GitHub deployments are now included on Personal, Premium, Business and Commerce plans; free sites are still excluded.
    • You enable it in the hosting dashboard under Settings → SFTP/SSH, then toggle SSH access on.
    • Use an SSH key rather than the generated password, and put two-factor on the account before you open the port.
    • Start with read-only commands: wp core version, wp plugin list, wp theme list, wp option get home.
    • Never run a database search-replace without --dry-run, and never run a reset on a live site.

    What actually changed

    The WordPress.com changelog published on 13 November covers 30 October to 12 November. The line that matters: the developer tools are “no longer just for Business plans and above”. On any paid plan you can connect over SSH or SFTP, run WP-CLI and Git commands, and deploy from GitHub.

    The support docs add details worth knowing:

    • It applies to plugin-enabled sites on Personal, Premium, Business and Commerce. Free-plan sites have to upgrade.
    • One set of credentials works for both SFTP and SSH. You create it once; “Reset password” issues a new one, with a one-minute wait between resets.
    • You can attach up to ten SSH keys to the account instead of using a password.
    • The dashboard prints the exact connection command. Copy it from there rather than assembling it from a blog post, including this one.

    One caution: the pricing page still lists these tools only on Business and Commerce while the changelog says every paid plan. If you are switching plans for the shell, ask support which page is current before you pay.

    Two settings before the first connection

    Two-factor on the account. Your account now controls a login that can edit files directly. Do this first; it takes two minutes and separates an inconvenience from a cleanup.

    An SSH key. Generate a key pair on your machine, paste the public key into the account, and keep the private key off the server. Keys can be revoked one at a time, which a shared password cannot.

    The baseline: five read-only commands

    Before you change anything, record the state of the site. All of these only read.

    wp core version
    wp plugin list --fields=name,status,version,update
    wp theme list --fields=name,status,version,update
    wp option get home
    wp option get siteurl

    The plugin list is the important one. Save it outside the server:

    wp plugin list --fields=name,status,version,update > plugins-before.txt
    scp user@host:plugins-before.txt ./plugins-before.txt

    Use the hosting file manager if SCP is awkward. That file is your before picture: which plugins were active, at which versions, and which had updates waiting. When something breaks next month, compare against it instead of trying to remember.

    The two option commands look trivial until you need them: home and siteurl are what a bad migration breaks, and having them written down has saved me more than once.

    The rescue move: a plugin that white-screens the site

    This is the reason the change matters. A plugin update throws a fatal error, the front end shows a blank page or a 500, and the dashboard may not load either. From the shell:

    wp plugin list --status=active --fields=name,version
    wp plugin deactivate plugin-slug

    Reload the site. If it comes back, that plugin was the cause — update it or leave it off.

    One wrinkle: if the broken plugin loads before WP-CLI starts, WP-CLI dies too. Skip it explicitly:

    wp --skip-plugins=plugin-slug plugin deactivate plugin-slug

    That flag stops WP-CLI loading the plugin for this one command, which is usually enough to get the deactivate through. Update or replace the plugin before you re-enable anything.

    Three commands that can take the site down

    Most WP-CLI commands are safe. A few are not, and they do not all stop to ask.

    1. Database resets. wp db reset and wp site empty drop tables or content. With --yes they skip the confirmation. There is no undo and no recycle bin. On a live site these are not maintenance commands; they are a decision to start over.

    2. Search-replace without a dry run. Changing a domain or moving from HTTP to HTTPS means running a search-replace across the database. Done wrong, it corrupts serialized data and leaves you with a site that loads but will not let you log in. The order is always: export the database, run it once with --dry-run, read the table counts, then run it for real.

    wp search-replace 'http://old.example' 'https://new.example' --dry-run
    wp search-replace 'http://old.example' 'https://new.example'
    wp cache flush

    3. Core updates you did not schedule. wp core update from the shell bypasses your host’s staging or backup routine. Fine when you are watching with a backup; bad at 11pm before a launch.

    Some managed hosts lock down database commands. If wp db export is unavailable, use the host’s backup tool and treat the shell as a place for plugin and core work only.

    The other half of the same changelog

    The same changelog expanded what a connected AI assistant can do: list your SSH keys, deploy GitHub repositories, change PHP and WordPress versions, read server logs, and delete or reset a site.

    Put that next to a cheap plan with a shell and the risk is obvious: an agent with file access and permission to reset a site is one bad instruction from an afternoon of restore work. Start on a staging copy, grant only what the task needs, and read the MCP settings instead of accepting defaults. I covered the narrower version in what an AI agent should be allowed to touch on a WordPress site.

    WP-CLI makes this easier and harder: commands are deterministic, but an agent can run twenty before you look. Keep what you run in a notes file or script.

    If your host is not WordPress.com

    The commands are the same everywhere; the access is not. Three things worth checking with your own host:

    • Is SSH included? Many shared plans include it but do not advertise it. Ask support directly rather than reading the plan table.
    • Is there a terminal in the panel? cPanel and Plesk often ship one. That is enough to run WP-CLI without a separate SSH account.
    • Can you install WP-CLI yourself? It is a single PHP file. Download the phar, run php wp-cli.phar --info, and alias it. No plugin required.

    What I would not do is install a plugin that puts a WP-CLI console in the browser on a live site. That adds an attack surface to avoid learning one command.

    The first-hour checklist

    Step Why it matters
    Two-factor on the account A shell login is worth stealing.
    Add an SSH key Revocable one at a time; no shared password.
    Save the plugin list to a file Your before picture for the next outage.
    Export the database, download it The shell cannot save you from a dropped table.
    Test a deactivate on staging The command you need at 2am should not be its first run.
    Write down home and siteurl Two values a bad migration breaks.

    Do the boring part today

    If your plan just gained a shell, the most valuable thing this week is not a clever command. It is the baseline: save the plugin list off the server, and export the database once so you know it works before you need it. Ten minutes now turns a future outage into a one-line fix.

    If you are on a plan without SSH, see what to back up and how to test a restore, and how to update core without opening an attack window.

  • Google’s November 2026 Core Update Is Rolling Out. What to Do This Week

    Google’s November 2026 Core Update Is Rolling Out. What to Do This Week

    The November 2026 core update started rolling out on 10 November, and Google says the rollout can take up to two weeks. For a small site the correct response is boring: freeze structural changes, save a clean baseline, fix only real errors, and spend the waiting time on one asset nobody else can copy. Then measure once, in December, when the data means something.

    I have watched this pattern for years. Day two, a page drops four positions, the owner rewrites the title and installs a new plugin, and three weeks later nobody can tell what caused what.

    The short version

    • The rollout began 10 November at about 10:06 a.m. Pacific. It applies globally, to all languages, and may run until roughly 24 November.
    • Ranking movement mid-rollout is noise. Google’s guidance: judge a full week after the update completes against the week before it started.
    • Do not touch titles, slugs, themes, redirects or old posts while it runs. Fix real errors only.
    • Export Search Console data for 3–9 November today. That baseline is the only clean one you will get.
    • Use the two weeks for the work that survives every update: a page of data or a tool only your site can produce.

    What is confirmed, and what it does not mean

    Google’s announcement was three sentences long. Most of the panic comes from reading more into it.

    What we know Confirmed What it does not mean
    Start 10 November 2026, around 10:06 a.m. PT That every change since then came from the update
    Scope Global, all languages That every country or query moves the same way
    Duration Up to two weeks, so around 24 November That a drop on day three is still there on day fourteen
    Type Broad core update, the third of 2026 after March and May That it targets your site, your niche, or a tactic you used

    A core update is a re-scoring of pages against everything published since the last one. It is not a penalty, and there is no list of banned techniques to check. The wrong response in week one — a rushed redesign — creates a second variable you can never separate from the first.

    Freeze the structure for two weeks

    Between now and the end of the rollout, the safe list is short:

    • No title or meta description rewrites on pages that were already getting clicks.
    • No slug changes, no redirects, no merging posts, no deleting “thin” pages on a hunch.
    • No theme switch and no new SEO plugin. Install one now and you will never know if it helped.
    • No mass internal-link edits across the whole site.

    What you should still fix: anything broken rather than underperforming. A 500 on one template, a URL in the sitemap that returns 404, a plugin with an active advisory. Those are bugs, and fixing a bug during a rollout is not chasing a ranking.

    Keep publishing on your normal schedule. A new post this week is not optimising for the update; it is just your job. If you need a plan for the next month that does not depend on today’s numbers, the process I use is here: How to Plan a Month of Content in One Afternoon.

    Save the baseline before you need it

    Google’s advice is to wait until the rollout finishes, wait one more full week, then compare that week against the week before 10 November. For this update, that baseline window is 3–9 November.

    Export it today. Search Console keeps 16 months, and your future self will not remember which week was clean:

    1. Open Performance, then Search results.
    2. Set the date range to 3–9 November 2026.
    3. Use the export button, not a screenshot. You want the Pages and Queries tables as CSV.
    4. In your analytics, annotate 10 November as “core update start”.

    Then write down every change you made to the site this month: moved pages, a new theme, edited titles, plugin updates. Half of what looks like an algorithm hit is your own edit from ten days ago. If Search Console is not set up properly yet, do this walkthrough before you read another ranking chart.

    A change log is enough, and it does not need to be a system:

    2026-11-13  core update day 4. no structural changes.
    2026-11-13  published: /google-november-2026-core-update-small-site/
    2026-11-18  plugin security update only. no config changes.
    2026-11-24  rollout window ends. still nothing structural.
    2026-12-01  compare the week against the Nov 3-9 baseline.

    The work that actually changes a small site’s numbers

    While the rollout runs, the useful question is not “what did Google do to me” but “what does this site have that no other site has”. A small tool-site owner posted a concrete answer on Indie Hackers this week, with numbers from Search Console: 48 clicks in the previous 28 days to 166 in the last 28, impressions from 7.46k to 21.8k, and no page lost clicks. The cause was not more articles. It was five changes.

    1. One page of original data. He collected Windows battery reports from four real laptops — two of his, his sister’s Lenovo, his brother’s HP — and put the numbers on one page with a chart and a downloadable CSV. Including the weird values: a battery that tripled for a day, 67 years of AC time in a week. Every guide on the site now links to that page. It is the first thing on the site nobody else could copy.

    2. Three small calculators. He kept doing the same arithmetic by hand while reading reports, so he built battery runtime, mAh to Wh, and charger wattage calculators that run in the browser with no upload — and gave himself honest reasons to link between guides.

    3. Titles rewritten to the query. Search Console showed impressions for searches his titles did not answer. “Laptop Stops Charging at 80%” became “Laptop Not Charging Past 80%? Turn Off the Charge Limit”. “Battery Health Percentage” became “How to Calculate Laptop Battery Health: Formula + Calculator”. Same content, different promise.

    4. The small trust fixes. A checker intro said “enter two values” and showed three fields. The homepage said Windows 10 and 11 while another section said 11 only. His name sat at the bottom of the About page; now it is in the first paragraph. Boring, and exactly what a reader or a reviewer notices.

    5. Crawl cleanup. A crawl found titles and descriptions that were too long, the tools index reachable at two URLs, an outdated support link, and a broken backlink. None of it exciting, all of it real.

    One case is not a formula, and the post is honest about what did not change: AdSense is still not approved, and the new data page itself is still “crawled, currently not indexed”. That is the most useful part. Original work does not rank on the day you publish it. It gives the rest of the site something to point at, and that is what compounds. Drafting is a solved problem — my own 90-minute workflow is what I use.

    What this looks like on my own sites

    The two sites I run are small. One sells hosting; the other is a set of free browser tools that has more tools than visitors. During this rollout I am not rewriting titles on either. I am exporting the baseline and building one page out of what I already own: questions from support mail and errors in my own logs. Not a guide to X. A page of what actually happened, with numbers and screenshots attached.

    The ten-day plan

    • Today: export 3–9 November, write the change log, touch nothing else.
    • Days 1–10: keep your publishing schedule, build one original asset, fix only real errors.
    • Around 24 November: check the Search Status Dashboard for the completion notice. Do not edit yet.
    • One week after completion: compare that week with the baseline. Pages tab sorted by lost clicks, then the Queries tab.
    • After that: fix the three pages that lost the most by answering the query better, not by writing ten new posts about the same thing.

    Do this today

    Open Search Console, export 3–9 November, and write one sentence: the asset only you could publish — your data, your tests, your screenshots, your support inbox. That sentence is the plan. The update will finish on its own.

  • An AI Agent Can Edit Your WordPress Site Now. What to Let It Touch

    An AI Agent Can Edit Your WordPress Site Now. What to Let It Touch

    Yes, let an AI agent edit your WordPress site — but not as you. Create a separate user for it, give that user a named application password, and turn write abilities on one at a time. The mistake almost everyone makes is clicking “Allow” on their own admin account because the screen offers it first, and that single click hands a chat window the same keys you use to change themes, install plugins and delete users.

    This stopped being a thought experiment this month. OpenAI opened “Businesses in ChatGPT” on 10 November, WordPress.com told owners on 11 November to install its plugin and manage their site from that chat, and the WordPress AI team shipped an MCP Access screen that finally lets you choose which abilities an agent can see. The plumbing works. The scoping is the part nobody explains.

    The short version

    • Your site can already be edited from a chat window. WordPress.com has MCP on all paid plans, and free sites plus self-hosted sites connected through Jetpack can use it free until 30 November 2026.
    • An agent should authenticate as its own user with its own application password. Never your admin login, never your account password.
    • Grant abilities by name, starting with read-only ones. “Full access” is a checkbox, not a decision.
    • Keep four things off permanently: user roles, plugin and theme installation, permanent deletes, and publishing without a human read.
    • After the first task, check the revisions and the log. That trail is how you prove what it did.

    What changed, and why it landed on your dashboard

    Three releases in fourteen days:

    • WordPress AI 1.5.0 (29 October) added an MCP Access experiment. It installs the MCP Adapter plugin and adds a Tools → MCP Access screen listing every registered Ability with a switch, plus your site’s MCP endpoint. Abilities in the adapter are private by default, so exposing one is now a deliberate act.
    • Uncanny Automator put an MCP server inside its free plugin on 2 November. Its free tier gives you 300 tool uses a day in the first week, then 150 a day — and its own documentation is blunt about the guardrails: you approve the connection as an administrator, choose read-only or read-and-write, and switch off any single action. Raw database changes and deleting users are never available to any AI.
    • WordPress.com published the ChatGPT plugin flow and, on 11 November, told business owners to install it. When you install it you pick Full access, Read only, or Keep existing access — and that choice applies to every AI you connect to the account, not just ChatGPT.

    Access is granted at the account or endpoint level, while the risk lives at the ability level. That gap is where a solo operator gets hurt.

    Three layers of access, and the default at each one

    Layer The default you will be offered What to choose instead
    Identity Authorize on your own account A dedicated user with the Editor role
    Tool set Full access — every Read and Write tool on Read only first, then one write ability at a time
    Credential Your password, or an admin app password A named application password you can revoke alone

    Step 1: Give the agent its own identity

    Go to Users → Add New and create a user called something obvious like agent-editor. Give it the Editor role, not Administrator. Editor can write, edit and publish posts, manage categories, moderate comments and upload media. It cannot touch plugins, themes, users or site settings — which means the worst possible prompt still cannot install anything.

    Then create an application password for that user. Application passwords are per-user, so you either log in as the agent user once, or use WP-CLI:

    wp user application-password create agent-editor "chatgpt-mcp" --user=agent-editor

    WordPress shows the password once. Copy it into the MCP client and nowhere else. Revoking it ends the agent’s access without changing your login, and every post it touches shows its name in the revisions — the same principle behind securing wp-login without a security plugin.

    Step 2: Turn abilities on by name, not by trust

    Open Tools → MCP Access and read the list before you switch anything. Every row is one thing an agent can do to your site, and the list is longer than most people expect. My order of enablement:

    1. Read abilities first. Site information, list posts, get post, search content, list media. With only these on, the agent can answer real questions — “which posts have no featured image”, “what did I publish in October” — and cannot change a byte.
    2. One write ability second. Updating post content or image alt text is a good first write, because the change is visible and reversible through revisions.
    3. Publishing last, if ever. Keep it in draft and read the output yourself. I already fact-check every AI draft line by line in this workflow, and an agent with publish rights skips that step silently.

    The abilities to leave off, in plain terms: anything with “delete” in the name, anything that creates users or changes roles, anything that installs plugins or themes, anything that writes site settings, and anything running arbitrary database queries. Uncanny Automator makes the same call in its own product — no raw database access, no user deletion. Those categories cost you a site, not an edit.

    Step 3: Run one bounded task, then read what it did

    Do not start with “clean up my site”. Start with a task that has an edge: “Update the alt text on the three most recent images in the media library. Change nothing else.” Then check four things:

    • Revisions on any post it touched — the diff should be small and boring.
    • Last edited by — it should be the agent user, not you.
    • Your host’s access log — the requests should come in a short burst, not a long crawl. If you have never read one, this is the five-minute version.
    • The plugin’s own log, if it keeps one. Agent Abilities records the acting user, ability name and argument keys for every call, denials included. WordPress core alone does not log MCP calls, so if nothing logs them you are trusting the agent’s own summary of what it did.

    If the trail looks wrong, revoke the application password — that is the whole rollback procedure, and it takes ten seconds.

    Four things I would not hand over

    1. User management. A role change or a deleted administrator is a lockout, not an inconvenience. There is no revision history for users.
    2. Plugin and theme installation. Updates are the most common way a working site goes down, so I do them in a window I control — see how to update core without opening an attack window. An agent updating plugins at 2am is that risk with worse timing.
    3. Permanent deletes. Deleted posts and pages sit in the trash for 30 days, but deleted media, categories and tags are gone immediately. There is no recycle bin underneath the recycle bin.
    4. Anything that spends money. If a plugin ability can place an order, charge a card or send a paid API call, it belongs to you and not to a tool that guesses intent from a sentence.

    The 20-minute setup, as a checklist

    1. Users → Add New: agent-editor, role Editor
    2. Users → agent-editor → Application Passwords: "chatgpt-mcp"
    3. Install MCP Adapter (or AI 1.5.0 → enable MCP Access)
    4. Tools → MCP Access: expose read abilities only
    5. Connect the AI client with the agent password, not yours
    6. Run one read-only task, confirm the log row appears
    7. Enable update-post-content. Leave publish and delete off
    8. Revoke the password when the experiment ends

    One check you can do in ten seconds

    Before you decide anything, check whether your site already answers on an MCP endpoint:

    curl -s -o /dev/null -w "%{http_code}" https://yourdomain.com/wp-json/mcp/mcp-adapter-default-server

    A 401 means the route exists and is asking for credentials. A 404 means no adapter is registered — which is good news only if you know it. The deadline worth diarising: free WordPress.com sites and self-hosted sites connected through Jetpack have MCP access free until 30 November 2026. If you want to try it, try it in the next two weeks, on a staging copy, as a user that is not you.

  • PHP 8.6 Ships on November 19: What to Check Before Your Host Switches You

    PHP 8.6 Ships on November 19: What to Check Before Your Host Switches You

    PHP 8.6 is scheduled to reach general availability on November 19, 2026, and I will not be installing it that week on any site I run. Not because the release is dangerous — it is a steady, boring release — but because on a WordPress site the PHP version is usually chosen by your host, not by you, and that is where the surprise comes from. Some hosts move every account onto the new branch within days of a release. Others leave you on an old branch until it stops getting security fixes. Either default can break a site nobody tested.

    Here is the check I run, in the order I run it.

    The short version

    • PHP 8.6 is scheduled for general availability on November 19, 2026.
    • WordPress 7.1 is tested and compatible through PHP 8.5. PHP 8.6 is not in the compatibility matrix yet.
    • The deadline that matters more is December 31, 2026 — the day PHP 8.2 stops receiving security fixes.
    • Confirm your real version in Tools → Site Health → Info → Server, not on your host’s feature page.
    • Test on a copy of the site with every error switched on, then read wp-content/debug.log.
    • Plugins break first. WordPress core almost never does.

    What 8.6 changes, and what it does not

    The new features are developer features: readonly property defaults, partial function application, a built-in clamp(), a Time\Duration class, better JSON error messages. None of that touches your front page. If you run a small site, you will never type any of it.

    What can touch you is the third category: code that was always sloppy and is now officially deprecated. PHP 8.6 deprecates things like returning a value from a constructor, a return inside a finally block, the third argument of define(), and several old type-check helpers. It also changes behaviour in a few places that matter quietly — session cookies now default to HttpOnly and SameSite=Lax, and trim() now strips form-feed characters by default.

    Deprecations do not break code on day one. They fill your error log and, on a badly behaved host, they print notices into your page output. The things that actually break are plugins that never got tested against a new branch.

    Step 1: find out what you are really running

    Three places, and they can disagree:

    Site Health. In wp-admin, go to Tools → Site Health → Info and open the Server section. The PHP version there is the one your web server actually hands to WordPress. This is the number that counts.

    Your host panel. cPanel, Plesk and most managed dashboards have a “Select PHP version” control. Look at it, but do not trust it alone — a panel can list 8.4 while a different PHP handler serves your domain.

    SSH, if you have it. Run php -v. Be aware this shows the CLI binary, which is often a different version from the one FPM serves. Use it as a cross-check, not as gospel.

    Write the number down, along with today’s date. You want to be able to say “I checked on 11 November and it was 8.2” if something changes under you later.

    Step 2: ask your host one question

    One support ticket resolves most of this: do you upgrade PHP versions automatically, and when? There are three possible answers and they lead to different plans.

    “We upgrade at release.” You have eight days. Test now, because the switch is coming whether you prepared or not.

    “We upgrade after testing, a few weeks later.” You have a buffer, not a guarantee. The same test still applies, just with a longer runway.

    “You choose the version in the panel.” Nothing happens automatically. Your only real deadline is the PHP 8.2 end of security support.

    Ask in writing and keep the reply. When a site breaks at 2am after a maintenance window, “the panel said 8.4” is not an answer your host will accept — a ticket with their policy in it is.

    Step 3: know which deprecations touch your site

    This table is the short list worth grepping for. Everything here still works in 8.6; the point is to know whether it is your code or a plugin’s.

    Deprecated in 8.6 Where I have seen it What to do
    return inside finally Custom snippets, older child themes Move the return out of the block
    Third argument of define() Legacy plugins with case-insensitive constants Drop the argument, or replace the plugin
    spl_object_hash() Old helper libraries bundled into themes Use spl_object_id()
    mb_ereg* functions Plugins doing multibyte regex work Watch for it; the library behind it is end-of-life
    Session cookie defaults Custom login and cart flows outside WordPress Retest logins and checkouts on staging

    Notice what is not on the list: nothing WordPress core does. Core is tested against each new branch before the matrix is updated. The exposure is always the third-party code you installed in 2021 and forgot about.

    Step 4: test on a copy, with errors switched on

    Half an hour on a staging copy beats a week of guessing. Copy the site, point a subdomain at it, then do three things.

    First, turn on logging so deprecations show up instead of hiding. In wp-config.php, set WP_DEBUG and WP_DEBUG_LOG to true and WP_DEBUG_DISPLAY to false — you want the notices in a file, not printed over your pages.

    Second, switch the staging copy to the PHP version you are testing, then walk the site the way a visitor would: home page, one post, search, a form, the login page, and the checkout if you sell anything.

    Third, read the log. This is the part people skip:

    # what the staging site is running
    php -v
    wp core version
    wp plugin list --status=active --fields=name,version
    
    # calls that 8.6 deprecates, by file
    grep -rn "spl_object_hash\|mb_ereg\|is_double\|is_integer" \
      wp-content/plugins wp-content/themes
    
    # anything the debug log recorded
    grep -c "Deprecated" wp-content/debug.log

    An empty debug log after a full walkthrough is the result you want. A long list of deprecations from one plugin is an argument for replacing that plugin, not for staying on PHP 8.2 forever.

    Step 5: if you are on PHP 8.2, December 31 is your deadline

    PHP 8.2 goes into security-only support and then stops on December 31, 2026. After that date, a vulnerability found in 8.2 will not be patched. That is a much more concrete risk than a new release arriving on a date you can plan around.

    My recommendation is to skip 8.6 for now and target PHP 8.5. It is inside the WordPress compatibility matrix, its active support runs to the end of 2027, and security fixes run to the end of 2029. PHP 8.4 is also fine today, but its active support ends on the same day as 8.2’s security support, so moving to 8.5 gives you a longer runway for the same amount of work.

    Move to 8.6 later, after WordPress 7.2 — the release currently scheduled for December 8, 2026 — has been out for a few weeks and your plugin list has caught up.

    The order I follow

    Today: note your version, open the host ticket, and take a fresh backup before you change anything. If you have not applied WordPress 7.1.4 yet, do that first — that update is closing an actively exploited hole, and the same discipline applies: back up, block the upgrade directory, then update.

    This week: copy the site to staging, run it on the PHP version you are targeting, and read the log. If the site already feels slow on the current branch, measure it before you blame the new version — a PHP upgrade can fix a slow site, but it can also just move where the time goes.

    Before December 31: leave PHP 8.2. Then check the log again 48 hours after any switch. If a plugin throws notices, replace it while you still have a working version to fall back to, not after the host forces the change on a Friday.

    The whole job is one support ticket, one staging copy, and one look at a log file. That is a much better use of an afternoon than discovering on November 20 that your host moved you and your contact form stopped sending mail.