AI and This Blog: Who Writes Here, and Why I’m Telling You

In June 2026, Cynthia Dunlop published survey results from 181 developers asking why they use LLMs to write blog posts (Report: Why developers use LLMs to write blog posts). One number stood out: 73% of developers who publish LLM-drafted content don’t tell their readers. This page exists so I’m not in that 73%. Consider this my full AI writing disclosure: AI is involved in producing these articles, and I’d rather you hear exactly how from me than guess it from the prose.

TL;DR — 73% of developers who publish LLM-drafted content never tell their readers — from Cynthia Dunlop’s June 2026 survey of 181 developers. This page is the other option. The ideas, the editorial judgment, the verification and the accountability are mine; research synthesis and prose drafting happen with Claude, under direction. Anything that cannot be checked against a running Magento 2 install gets flagged rather than asserted. If something here is wrong, that is on me, not the tool.

The lead: why disclosure matters

There’s a version of AI disclosure that functions as a hedge — small print nobody reads, written to satisfy a policy while changing nothing about the reader’s experience or their ability to calibrate trust. That’s not what this is.

If you’re going to use a tool this capable in producing content you ask working engineers to rely on for real decisions, you owe them an honest account of how it works and what it means for accuracy. The survey makes the shape of that debt concrete: 73% of developers publishing AI-drafted content say nothing. The disclosure gap is structural, not accidental. Filling it requires being specific.

The baseline: what the survey actually found

The findings cut through the usual binary of "AI slop" versus "real writing."

LLM use clusters at the inexperienced end of the writer population. Among developers who always draft with an LLM, around 40% had never written blog posts before at all, and their dominant motivation was obligation — a company or role that requires publishing. That’s the cohort producing most of what gets called slop: people who didn’t want to write, told by their employer to write, handing the whole job to a model. The output is plausible text that doesn’t capture experience, because no experience was in the room.

The middle of the distribution is more interesting than the extremes. Most respondents who use LLMs at all still do the heavy lifting themselves: 72% reported substantial editing of generated drafts, and another 23% rewrote them entirely. Only 13% felt the output sounded like them. Only 11% felt it captured their actual thinking. Even people who fed the model their own rough draft as context mostly didn’t recognise the result as their own work.

Read plainly: the developers in that survey are not outsourcing their thinking. The model produces material; the human produces the article. The tool does roughly what a very fast, very literal junior collaborator would do — and the author does everything a senior one does.

The HBR article "AI Is Going to Change the 80/20 Rule" frames the structural consequence: AI does not flatten the Pareto distribution in knowledge work — it steepens it. The developers who identify which slice of their work is irreplaceable and protect it will pull further ahead; those who hand that slice to AI will converge toward output that satisfies no one. The survey’s obligation cohort has already done the latter: they delegated everything, including the 20% that would have made the output worth reading.

The tradeoff: three positions on AI in writing

Full delegation — the obligation cohort

The obligation group hands the entire job to the model: no prior experience, no investment, a checkbox to clear. The output is plausible text with no epistemic grounding. The author can’t defend it because they weren’t there for it.

Strengths: minimal time cost; satisfies a publishing volume requirement

Costs: no signal value for the reader; every wrong claim becomes the author’s problem with no way to diagnose it

Full authorship — writing as thinking

Some respondents declined LLM involvement entirely on principle. The argument is coherent: writing is thinking made legible; outsourcing the draft outsources the reasoning. The model imposes its own linguistic habits on the author’s ideas, and by the time you’ve edited it into something that "sounds like you," you’ve been shaped by the model’s initial frame more than you realise.

Strengths: maximum signal density; the author can defend every inference

Costs: high time cost; the article that doesn’t exist benefits no one

Collaboration — the working middle

Author provides ideas, context, and direction; model drafts and researches under that direction; author edits, verifies, and signs off. Neither party is optional. The model accelerates the mechanical steps; the author supplies the domain knowledge and stakes their reputation.

Strengths: practitioner knowledge reaches publication; the hours between "I know what this should say" and "it exists" collapse

Costs: requires discipline to keep verification and pushback in the loop; easy to let the model drift into confident vagueness if the author stops challenging it

A working example: how this blog divides the labour

I want to be specific about the division rather than hiding behind a vague "AI-assisted" label.

The ideas are mine. Every article here starts from something I hit in real Magento 2 work: a Monolog 3 upgrade that broke logging assumptions, a pull request I got merged into core, a translation workflow gap I wanted a module for. The backlog is groomed by me, by hand — deciding what’s worth writing is judgement built on knowing the codebase and the community. An LLM will cheerfully rank topics by criteria that don’t matter.

The research and drafting are collaborative. I work with Claude iteratively: it does targeted research to establish factual grounding — version-specific behaviour, API changes, what the official docs actually say today — and it drafts sections under my direction. I push back, redirect, cut, and rewrite until the article says what I mean. The value isn’t in the first draft sounding like me; it’s in having something concrete to argue with, section by section, until it does.

The verification is mine. Code in these articles targets the actual Magento 2 version I run. Anything I can’t verify on a live store is flagged in the article rather than asserted. An LLM can write a plausible di.xml. It cannot tell you it works. That part doesn’t compress.

The accountability is mine. If something here is wrong, that’s on me, not the tool. I put my name on it; I can defend every line.

Put it in Pareto terms: the ideas, editorial judgment, and verification are the 20% of inputs that drive 80% of the article’s value to the reader. Research synthesis and prose drafting are the 80% that AI compresses — without changing what the article actually knows. The obligation cohort in the survey inverted this: they delegated everything, including the 20% that would have made the output worth reading. The result is plausible text that tells you nothing a search result wouldn’t, signed by someone who can’t defend it.

One respondent in the survey described their process as gathering notes, having the LLM build a coherent outline, drafting from that, then using the model to stress-test the argument. That’s close to how this blog works, with one inversion: the model drafts more here, and I verify more. For technical reference content — where the reader needs the di.xml to be correct far more than they need my prose rhythm — I think that’s the right trade. This is documentation-shaped writing, not essay-shaped writing.

Verification: the full disclosure

Here it is in full:

Articles on this blog are written in collaboration with AI (Claude, by Anthropic). The topics, technical experience, and editorial judgement are mine; research and drafting are AI-assisted under my direction; all code targets the Magento 2 version stated in the article and anything unverified on a live store is flagged as such. If you find an error, it’s my error — get in touch.

If that’s a dealbreaker for you, fair enough — the "never" group made coherent arguments for writing as thinking and I don’t dismiss them. But the Monolog 3 LogRecord change invalidated nearly every logging tutorial online. Somebody should write the corrected version. The limiting factor on that happening was never knowledge — it was the hours between "I know exactly what this article should say" and "the article exists." AI collapses that gap. The alternative isn’t a hand-crafted version of the same article appearing later. For most of these topics, the alternative is the article never existing, and the next developer spending the same afternoon I did rediscovering the same breaking change.

The test I hold these articles to is the one that matters for reference content: is it accurate, is it complete where the official docs aren’t, and does it save you an afternoon? Judge it by whether the code runs.


This page was, naturally, also written in collaboration with AI — and edited, verified, and signed off by a human who has actually shipped the things it describes.

Related Topics

← Previous
Next →

Written in collaboration with AI (Claude, by Anthropic). Ideas, verification, and accountability are mine; research and drafting are AI-assisted. Full disclosure → · Found an error? Tell me.