Blog

  • 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.

  • How to Update WordPress Core Without Opening an Attack Window

    How to Update WordPress Core Without Opening an Attack Window

    WordPress 7.1.4 is a security release, and the flaw it fixes is already being exploited in the wild. The uncomfortable part is that on an unpatched site, the update itself is the attack window: WordPress unpacks the new files into a folder inside your web root and finishes installing them while still running the old, vulnerable code. Two habits close that window — take a backup, and block web access to wp-content/upgrade before you click Update.

    The flaw is CVE-2026-119977, a time-of-check to time-of-use race in WordPress’s core upgrade process. It affects versions 4.7 through 7.1.3. WordPress shipped the fix on October 28, and CISA has since added the flaw to its known-exploited list after confirming attacks in the wild; Wordfence said it blocked 13,095 attempts against it in a single 24-hour stretch. This is not a theoretical hardening post.

    The short version

    • CVE-2026-119977 can give an unauthenticated attacker code execution during a core update. It is fixed in WordPress 7.1.4.
    • Versions 4.7 to 7.1.3 are affected, and the patch was backported to older branches, so check what you are actually running.
    • Blocking /wp-content/upgrade/ at the web server kills the attack without stopping the updater.
    • Order matters: back up, block, update, verify. Blocking after the update is too late for that update.
    • The plugin queue is bigger than the core queue — 549 plugin vulnerabilities were disclosed in a single week.

    What the flaw actually does

    When WordPress updates core with a full package, it downloads a complete copy of the new version and unpacks it into a temporary folder inside wp-content/upgrade/. That copy includes the installer. The folder lives under the web root, so the web server will happily serve files from it.

    The temporary folder used to have a name an attacker could predict or find. So the sequence is: you start the update, WordPress writes the new files into a reachable folder, and an attacker who is polling for that folder loads the installer and completes an install before WordPress deletes the copy. That is code execution with no account and no password. The 7.1.4 fix gives the temporary folder a random name, so there is nothing left to guess.

    Worth being honest about the shape of the risk: it is a narrow window and a high-complexity attack. It is not a drive-by. But narrow windows are exactly what automated scanners are built to hit, and “high complexity” stops meaning much when the scanning is free.

    Who is actually exposed

    • Sites on 4.7 to 7.1.3 that have not updated since October 28. That is the whole affected range, including old installs people forgot they own.
    • Shared hosting, most of all. When WordPress cannot write core files directly, it falls back to the full-package upgrade — the exact code path this bug lives in.
    • Anyone who turned off auto-updates and then stopped checking. Turning off auto-updates is a legitimate choice; turning off the calendar reminder that goes with it is not.

    If you are already on 7.1.4 or newer, the flaw does not apply to you, but the habit still does. If your host patches for you, ask for the core version number rather than for reassurance — the answer is a version, not a feeling.

    The five-minute update order

    Do these in order. The block has to exist before the update runs, not after.

    1. Back up the database and the files. A database export plus a tarball of the site directory. If you have never restored one, test the restore before you need it.
    2. Block the upgrade folder at the web server. On nginx, add a location block that returns 403 for ^~ /wp-content/upgrade/. On Apache or LiteSpeed, add a rewrite rule in the site’s root .htaccess. This only refuses HTTP requests; PHP can still write to the folder, so the updater keeps working.
    3. Update core. Dashboard → Updates → Update now, or from the command line with WP-CLI.
    4. Verify. Confirm the version, verify core checksums, then load the homepage and the login page while logged out.
    5. Leave the block in place. It costs nothing and closes the same trick in the next security release.
    # 1. Back up before anything
    wp db export ~/backup-$(date +%F).sql
    tar czf ~/files-$(date +%F).tar.gz public_html
    
    # 2. Block the upgrade folder (nginx), then reload nginx
    #    location ^~ /wp-content/upgrade/ { return 403; }
    #
    #    Apache / LiteSpeed: put this above the WordPress block
    #    in the site root .htaccess:
    #    RewriteRule ^wp-content/upgrade/ - [F,L]
    
    # 3. Update and verify
    wp core update
    wp core version
    wp core verify-checksums
    
    # 4. Plugin queue
    wp plugin list --update=available
    wp plugin update --all

    If a host control panel runs updates for you and something breaks while the folder is blocked, remove the rule, run the update, and put it straight back. What you do not want is an update that starts, fails halfway, and leaves a half-unpacked copy sitting in a web-reachable directory while you go looking for the cause.

    The plugin queue is bigger than the core queue

    Wordfence’s weekly report for October 26 to November 1 counted 549 vulnerabilities across 351 plugins and 4 themes, including 17 critical and 132 high-severity disclosures. Forty-one had no patch at the time of disclosure. You cannot update your way out of those — the only move is to deactivate and delete.

    A separate batch documented on November 9 covers 13 plugins, and four of them are common enough to check by name:

    Plugin Installs Problem Action
    LatePoint 100,000 Auth bypass, CVSS 9.1, through 5.7.6 Update now
    TranslatePress 400,000 Two stored XSS via comments, CVSS 7.2, through 3.3.8 Update now
    Amelia 90,000 SQL injection plus missing authorisation, CVSS 7.5, through 9.9.1 Update now
    wpForo 20,000 SQL injection and subscriber-to-admin escalation, CVSS 7.5, through 3.2.2 Update now

    None of these plug straight into core, so they are not today’s headline. They are the reason “I updated WordPress” is not the same statement as “I patched my site”. A booking plugin with an authentication bypass is a worse day than a narrow core race condition, and it does not announce itself.

    How to tell whether someone hit you during an update

    Three checks, five minutes, no plugins required:

    • Access logs. Search for requests to /wp-content/upgrade/, especially POSTs to an installer file from an address that is not yours. Reading access logs is the same skill as spotting a brute-force run, pointed at a different string.
    • Administrator accounts. List the administrators and compare the registration dates against the day you ran the update. A new admin you did not create is the whole answer.
    • Unexpected files. Anything ending in .php inside uploads, mu-plugins, or a leftover upgrade folder that you did not put there. This is part of the five-minute infection check.

    If two of the three come back dirty, stop tidying and treat the site as compromised. Cleaning the symptom without finding the entry point is how a site gets reinfected a week later; the recovery order is: isolate, preserve evidence, rebuild from a known-good backup, then rotate every credential that touched the site.

    The checklist I actually run

    • Core version is 7.1.4 or newer on every site I am responsible for, including the one I forgot about in September.
    • /wp-content/upgrade/ returns 403 from the public internet.
    • A backup from the last seven days exists, and one restore has been tested this year.
    • No active plugin has a published, unpatched vulnerability — those get deleted, not “monitored”.
    • Access logs checked for upgrade-folder requests in the last 30 days.
    • One admin account per person who actually needs it, and nobody’s old developer still on the list.

    None of this is exciting, which is the point. Sites rarely get hurt because the owner lacked a clever security stack. They get hurt because a three-week-old security release looked like a maintenance chore, and the update window stayed open while nobody was watching.

  • How to Fact-Check AI Drafts Before Publishing

    How to Fact-Check AI Drafts Before Publishing

    A benchmark reported yesterday by Alibaba researchers should be pinned above every content calendar. They collected 37,463 real requests from 26,314 coding sessions where people had struggled to get an AI assistant to finish a job, refined them into 273 tasks with 2,331 hidden acceptance criteria, and ran ten leading models through them. The best model, OpenAI’s GPT-6 Astra, met an average of 69.9% of the criteria per task. It fully solved 26.4% of the tasks. On multi-file repository edits, that figure fell to 17.9%.

    Coding is not blogging. But the shape of the failure is the same: the draft looks finished, most of it is right, and the last quarter is where the damage lives. A wrong version number, an invented quote, a link that goes nowhere, a confident sentence about something the model cannot know.

    So I do not publish an AI draft until it has been through a review pass that treats every factual sentence as a claim to be checked. Not a vibe check. A source check. Here is the exact pass I use.

    The short version

    • Assume every number, name, date and quote is wrong until you have opened a source.
    • Check the link, not just the claim. A dead or mismatched link is a factual error with a URL attached.
    • Delete any first-person experience the draft invented, and replace it with one you actually had.
    • Soften what you cannot verify, and say so plainly instead of sounding certain.
    • Read the finished piece aloud once. Confident nonsense survives silent reading and dies at speaking speed.

    Why AI drafts fail in the same five places

    After enough drafts, the errors stop being random. They cluster in five predictable places.

    1. Numbers without a source. A percentage appears with three decimal places and no origin. It may be real, remembered from somewhere, or invented to make the sentence sound researched. You cannot tell by looking, which is the point.
    2. Citations that do not exist. Titles, authors, journals and years that read plausibly. Ask for the URL and you get a 404, or a page that says something else entirely.
    3. Stale product facts. Pricing, limits, version numbers and feature lists change faster than training data. A sentence can be true in the model’s memory and false on the vendor’s site today.
    4. Borrowed experience. “When I tested this last month…” from a model that has never opened the tool. This is the most damaging one, because readers forgive a wrong number far more easily than a fake story.
    5. Confident predictions. “This will kill X” is an opinion wearing a fact’s clothes. It needs to be labelled as a bet, not delivered as a finding.

    Google’s documentation update this month makes the same point from the other side: it now tells publishers to fact-check and review AI-generated content before publishing, and warns against manufactured authorship. The compliance bar is no longer “did a human touch it?” It is “can you stand behind what it says?”

    The five-minute pass

    Five minutes is not enough for a 3,000-word research piece. It is enough for a 1,200-word blog post if you work in the right order. I keep the draft on the left and a browser window on the right, and I do not edit prose until the facts are settled.

    1. Mark the claims. Read the draft once and highlight every proper noun, number, date, quote and superlative. Do not fix anything yet. You are making a list, not editing.
    2. Open the primary source. Not a blog quoting a blog. For a study, the paper. For a product claim, the vendor’s own documentation or changelog. For a quote, the transcript or the recording. If the best you can find is a summary of a summary, the claim is not verified, it is repeated.
    3. Click every link. Check that it loads, that the title matches what you said it says, and that the date is current. A link that resolves to the right domain but the wrong page is worse than no link, because it looks like evidence.
    4. Rewrite from the facts, not from the draft. Once a claim is confirmed, write the sentence yourself using the source in front of you. This one habit removes most accidental plagiarism and most of the model’s smug tone at the same time.
    5. Read it aloud. Slowly. The sentence you skated past silently is usually the one that says nothing, or says something you cannot defend.

    A claims table you can keep

    When a piece has more than a handful of facts, I keep a small table beside the draft. It turns “I think this is right” into a yes or no. Mine has four columns, and the last one is the only one that matters.

    Claim type Looks like Check against If unverified
    Number “42% of sites…” The original study or dataset Cut the number or say “many”
    Quote “…” — named person Transcript, video, original interview Paraphrase the idea, not the words
    Product fact “Version 7.2 supports…” Vendor changelog or docs Say “check current docs” or cut it
    Personal story “When I tested this…” Your own notes or screenshots Cut it or run the test for real
    Link “Source: example.com” Open it; read title and date Delete the link and the claim

    The prompt I add before the first draft

    Most cleanup can be avoided by asking the model to expose its uncertainty instead of smoothing it over. I paste this after the brief, before any drafting starts. It does not replace the check. It makes the check shorter.

    Before you write, list the five factual claims this article will depend on. For each one, give the primary source you would use and mark it certain, uncertain, or unknown. Do not invent sources to fill the table.
    
    Then write the draft, and put [VERIFY] after every number, name, date, quote or product detail you are not certain about. Do not round over gaps.
    
    At the end, list the three sentences most likely to be wrong, and why.

    Two things to note. First, the model will still miss claims, especially ones it believes are common knowledge. The [VERIFY] tags are a floor, not a ceiling. Second, a source URL from a model is a lead, not proof. Open it. Read it. If it does not say what the draft says it says, the draft is wrong.

    What “verified” means before I press publish

    My standard is one question: if a reader emailed “where did you get this?”, could I answer in one sentence with a link or a specific experience? If the answer is a shrug, the sentence is not ready.

    That standard changes how the piece is written. A fuzzy number becomes “roughly” or disappears. A prediction becomes “I think” or gets cut. A product detail gets a date stamp: “as of November 2026” tells the reader when the fact was true, which is often more honest than pretending it is permanent.

    It also keeps the publishing workflow boring, which is what you want. The 90-minute post workflow leaves a real slot for this pass instead of pretending the draft is the finish line. The monthly planning afternoon is where the topics come from, so the writing day starts with decisions already made. And repurposing happens only after the facts survive, because a wrong number copied into five formats is five times the problem.

    Pre-publish checklist

    • Every number has a source open in a tab, or it is gone.
    • Every quote is verbatim from a primary source, with the speaker named correctly.
    • Every link loads and matches the claim it supports.
    • No first-person experience that I did not actually have.
    • No prediction stated as a fact; bets are labelled as bets.
    • Product names, versions and prices checked today, with a date stamp.
    • The whole piece read aloud once, start to finish.

    Next time you have a draft that feels finished, set a timer for five minutes and try to disprove it. Open the first number. Click the first link. Read the first quote. If everything survives, publish with confidence. If something does not, you just caught the 74% before your readers did.

  • How to Plan a Month of Content in One Afternoon

    How to Plan a Month of Content in One Afternoon

    Planning a month of content does not take a month. It takes one afternoon, and most of that afternoon is not writing.

    My version produces four titles, four skeletons, four hero images and a calendar with two dates per post. I do it in one block of roughly four hours on a Sunday, and then I stop thinking about content strategy until the next month. The writing still happens on weekdays, in 90-minute blocks, the way I described in how to write a blog post in 90 minutes.

    Planning and writing use different parts of your head. Planning is judgement: what is worth writing, in what order, with what promise. Writing is focus: one section at a time, no decisions. Mixed together, I make bad decisions and shallow drafts in the same hour.

    The short version

    • Block four hours once a month and do not spread planning across the week.
    • Build the topic list from questions you have already answered before inventing new ideas.
    • Leave the afternoon with four titles, four skeletons and four images — not twelve half-drafts.
    • Put two dates on every post: publish day and repurpose day. One date means the post dies after a week.
    • Keep one slot empty for the story that turns up mid-month.

    What the afternoon actually produces

    Not articles. The output of a planning afternoon is a folder of decisions that a tired version of you can execute later without thinking.

    At the end of four hours I want these in one place: four titles I would defend, four skeletons with headings and the asset each one needs, four hero images at final size, and eight calendar entries. Nothing else. If I end the afternoon with two finished drafts and no plan, I have solved this week and borrowed against next week.

    The plan has to survive a bad Tuesday. A skeleton promises my future self that the thinking is done; a half-written draft still forces me to decide what the second half argues.

    Hour one: mine the topic bank you already own

    Most people start this hour by brainstorming, which is the slowest method available. I start with four sources that working already generated:

    1. Search Console queries where I rank between roughly position 5 and 20. Those pages Google already understands but has not promoted, so a more precisely aimed post has a reason to exist. Search Console is the only free tool that tells me what strangers typed to find me; the setup steps are in how to set up Google Search Console properly.

    2. Questions I answered twice in email or chat. The rule is mechanical: if I typed the same explanation twice, it becomes a topic. I keep a plain text file called questions.md and paste the question in as it arrives, not the answer.

    3. Comments and replies that pushed back. Disagreement is a better topic source than praise, because the person is telling me exactly which part of my argument is unclear.

    4. Posts that got replies but no clicks. Usually the title promised one thing and the article delivered another. The fix is a rewrite or a follow-up that answers the question the title implied.

    At the end of the hour I want 8 to 12 candidate lines, each a single sentence that starts with the reader’s problem, not my subject. “Why does my WordPress site show a 500 after I edited functions.php” is a topic. “PHP error handling” is a category.

    One filter: if a topic needs numbers I do not have — revenue, traffic, client results — it goes to a parked list until I actually have them.

    Hour two: four titles and four skeletons, no drafts

    Four is not magic: it is roughly how many posts I can hold in my head, and it leaves room for the unplanned post that always appears. Twelve planned posts become debt.

    I write each title first, because the title is the promise the article has to keep. Two shapes do most of the work:

    • How to X without Y — the reader gets a method and a constraint at the same time.
    • What X actually means (and what to do about it) — good for error messages, policies and anything where the reader is confused before they are curious.

    Then the skeleton: five lines maximum — three to five headings plus the one concrete asset the post needs. I write it in a plain file:

    title: How to X without Y
    promise: reader can do X by the end, with Y still in place
    asset: one table comparing the options
    h2: What X actually needs
    h2: The three steps
    h2: Where it breaks
    h2: Checklist
    links: /write-a-blog-post-in-90-minutes/, /google-search-console-setup/
    repurpose: newsletter + 2 short videos

    Six minutes each, and the article has a shape before I start writing: at 7am on a Wednesday I can read six lines and type, instead of deciding what the piece is about.

    Hour three: batch the parts that do not need your brain

    Hero images, slugs, excerpts, categories and internal links are small decisions that interrupt writing one at a time, so I make them all at once at planning time.

    I generate the four hero images from final titles with my own script, so the card text is already correct and alt text gets written in the same minute, while I remember what the article argues. Slugs and excerpts go into the same file as the skeleton.

    The internal links are the part people skip, and it is the part that compounds. Every planned post gets two links back to older articles and one forward link to a post scheduled later in the month. That forward link only exists if you plan a month at a time, and it keeps the archive getting crawled instead of going quiet after week two.

    Hour four: two dates per post, not one

    Every post gets a publish date and a repurpose date two or three days later. The second date is not optional. Publishing without a repurpose slot is how a good article reaches forty people and disappears.

    The repurpose block is about 45 minutes and it is mechanical: pull the promise for the newsletter, the headings for the video beats, the steps for a forum answer, and one line for social. I wrote the full set of cuts in my content repurposing workflow, and none of it requires a new idea.

    Hour Output Done when
    1 8–12 candidate topics at least four you would actually write
    2 Four titles, four skeletons each has headings and one named asset
    3 Images, slugs, excerpts, link map files exist with final titles and alt text
    4 Eight calendar entries publish and repurpose dates both set

    Where this plan falls apart

    Four failure modes I have hit:

    Planning too many posts. Twelve planned posts feel productive and produce nothing, because each one is a decision I have to re-open. Four keeps a weekly rhythm with slack.

    Planning posts that need data. A topic like “what my first month of hosting actually earned” cannot be planned before the month exists. If a skeleton has a number I cannot fill in today, it is parked.

    Skipping the repurpose date. The article ships, the newsletter does not, and the month looks busy while the audience stays flat.

    Treating the plan as a contract. If a story lands that fits the blog, it takes the empty slot, not a fifth squeezed in on top. The plan removes decisions; it does not forbid judgement.

    The test of a good afternoon

    If I can open the folder on a Wednesday morning, read one skeleton, and be typing within two minutes without deciding anything, the afternoon worked. If I open the folder and start reorganising the list, it did not — that is planning as procrastination.

    The checklist I actually run before closing the file:

    • Four titles, each a promise a reader can repeat out loud.
    • Four skeletons with three to five headings and one named asset.
    • Four hero images generated from the final titles, with alt text.
    • Eight dates: four publishes, four repurposes.
    • One empty slot left deliberately blank.

    Block the next four hours before you close this tab. The month is cheaper to plan than to improvise, and improvising is what makes publishing feel like a second job.

  • My Content Repurposing Workflow: One Post, Five Formats

    My Content Repurposing Workflow: One Post, Five Formats

    One blog post should leave the house as five pieces of content, and the trick is that you never write any of them from scratch. After the article is published I spend about 45 minutes cutting the same material into a newsletter, a short video script, a social post, and a forum answer. Each format pulls from a different layer of the post, which is why the words come out fast and still sound like they were written for that place.

    I covered the writing half of this in How to Write a Blog Post in 90 Minutes. This is the second half: what happens to the file after I hit publish.

    The short version

    • Treat the finished post as raw material, not a monument. Every other format is a cut of it.
    • Each cut takes a different layer: the promise, the skeleton, the proof, or one quotable sentence.
    • Give each format one job. Newsletter for relationship, video for reach, social for distribution, forum for credibility.
    • Do all four cuts in one sitting, while the thinking is still in your head.
    • Five formats is a ceiling, not a quota. Skipping one is a decision, not a failure.

    Start from layers, not from a blank page

    Most repurposing fails because people open a new document and try to write a post about the article. That is a rewrite with extra steps. The faster path is to accept that the post contains everything you need, just packed for one reader in one mood.

    Before I cut anything, I break the article into four layers:

    • The promise — the sentence in the intro that says what the reader gets. It becomes the newsletter subject line and the first line of the social post.
    • The skeleton — the H2 headings. They become the video beats, because they are already an ordered argument.
    • The proof — the steps, commands, settings, or examples. They become the forum answer.
    • The quotable line — the one sentence I would underline. It becomes the opening line of the video and the hook of the social post.

    Once those four things exist, repurposing is selection, not creation. That is the whole trick.

    The five cuts, in order

    This is the shape I work to. The times are what the cutting takes me once the article is live, not the time to write the article.

    Format Cut from Time Job
    Blog post (source) Outline and draft 90 min The asset you own and can rank
    Newsletter Promise and skeleton 10 min Relationship with people who opted in
    Short video script Skeleton and proof 10 min Reach on a platform you do not own
    Social post Quotable line and link 5 min Distribution to people who will never subscribe
    Forum answer Proof section 15 min Credibility where the question is already being asked

    The newsletter: send the promise, not the post

    The mistake here is pasting the whole intro and calling it a newsletter. People subscribed to hear from you, not to get a second copy of a page they can read for free. I send 150 to 250 words: the promise, three bullets from the skeleton, and one link. If I cannot explain the value in three bullets, the article probably has more than one idea in it.

    Subject: [the promise, rewritten as a question or a number]
    
    One sentence on why this matters this week.
    
    - The problem, in the reader's words
    - The step most people skip
    - What to do first
    
    Full post: [link]
    
    That is the whole email. No preamble, no signature block longer than one line.

    Two rules: the subject line describes what is inside, and the bullets are useful on their own. A newsletter that only works if you click is an ad.

    The video script: your headings are already the beats

    A 30 to 45 second script does not need a scriptwriter. It needs three beats, and the article already has them. I take the problem from the intro, the method from the first two or three H2s, and the proof from whatever concrete example the post contains. Then I write it as spoken lines, one idea per line, eight to ten words each.

    The shape that works for me:

    • Beat 1, problem (0–5s): the viewer’s own complaint, said plainly. No greeting, no “in this video”.
    • Beat 2, method (5–25s): the two or three steps, in order, with the reason attached to each one.
    • Beat 3, proof (25–35s): the specific result from the post — the log line, the setting, the thing that changed.
    • Close (35–40s): one action, one place to go.

    If a beat needs a diagram to make sense, it belongs in the post.

    The social post: lift one paragraph and stop

    Social is not a summary. A summary of a long article is boring in every format. What travels is one opinionated sentence, stated without hedging, followed by enough context to be useful and a link for the people who want the rest.

    My routine: pick the most contrary sentence in the article, paste it first, delete every word that softens it, then add one line of value and the link. On X the limit is 272 weighted characters and a link counts as 23, so the real text budget is around 250. No hashtags there; they read as spam. On LinkedIn or Facebook I add a line break before the link so the post does not end in a wall of URL.

    What I never do is announce that I wrote a blog post. Nobody owes me a click because I was productive. The sentence has to earn it.

    The forum answer: answer first, link second

    Forums are where the same question gets asked every week, and the easiest place to be useful if you resist advertising. I find a thread where I actually know the answer, then write the answer as if my site did not exist. Only at the end, if there is more detail than a forum reply should carry, do I mention that I wrote it up in full.

    Practical version: lead with the direct answer in the first two lines, give the steps in the order you would do them, and name the one thing that usually goes wrong. Strip the brand voice completely. A forum reader can smell a marketing line in the first sentence, and then the answer is dead no matter how correct it is.

    What I skip, and why five is a ceiling

    Not every post deserves five cuts. Some topics are useful and quiet; they earn a newsletter mention and nothing else. Others are already saturated on video and do better as a written reference. I decide based on where the question lives, not on a content calendar that says every post gets five assets.

    Things I skip by default: Instagram carousels, because the design time eats the writing time; podcast appearances, because they are a different skill; and old forum threads. Things I only do when the post is genuinely strong: a second video, a longer LinkedIn version, and a follow-up article that goes deeper on one section.

    Two weeks after publishing, I check which pieces earned impressions and which earned nothing, then put the next month’s effort where the numbers actually moved. That is a Google Search Console habit, and I wrote the setup for it in How to Set Up Google Search Console Properly. Repurposing without that check is just making more things.

    The 45-minute checklist

    1. Copy the promise sentence and the H2 list into one scratch file.
    2. Write the newsletter from those two things only. No new ideas.
    3. Turn the H2 list into three video beats and one closing action.
    4. Lift one paragraph for social, cut it until it fits, add the link last.
    5. Find one real question and answer it with the proof section, brand voice off.
    6. Schedule all four and log them in a single row of a spreadsheet: date, post, formats, links.
    7. Set a reminder for two weeks out to check impressions before deciding what to repeat.

    The post is not finished when it is published. It is finished when the same idea has met five different readers in the five places they already spend time, and none of them had to be told it was the same idea.