Photo by Carter Hightower on Unsplash
For about a year my "AI writing workflow" was a chat window and a clipboard. Paste in some notes, ask for a draft, copy the draft out, fix it by hand, paste the fixed version back in when I wanted a shorter one. It worked the way a calculator works: useful, but I was still the one doing the job.
Lately I've been moving pieces of that into something closer to an agent - a loop that gets a goal, gathers its own sources, drafts, checks its own work, and hands me something to review at the end. People have started calling this "agentic content." I think the term is mostly hype, but the change underneath it is real, and it changes what the hard parts are.
This is my honest take after running a few of these pipelines for internal docs, release notes and a couple of long-form posts.
What actually changes
The simplest way I can put it: with prompt-and-paste, you are the control flow. You decide what to ask next, you notice the draft is wrong, you go find the missing fact. With an agentic setup, the model is making some of those decisions, and your job moves from writing to designing the loop and reviewing its output.
Anthropic's engineering post Building effective agents draws a line I've found useful. It separates workflows, "systems where LLMs and tools are orchestrated through predefined code paths," from agents, where the model directs its own process and tool use. Most of what gets sold as agentic content is really the first kind, and honestly that's fine. The same post recommends "finding the simplest solution possible, and only increasing complexity when needed," and notes that agentic systems "often trade latency and cost for better task performance."
That matches my experience. My most reliable content pipeline is barely an agent at all. It's a fixed sequence: pull source material, outline, draft section by section, then run a separate review pass against a checklist. The model only gets freedom inside each step.
Where it works
1. Turning a lot of material you trust into a shorter thing. Release notes from merged PRs. A summary deck from a design doc. A changelog from commit messages. The source is known, the facts are already there, and the agent's job is to select and restructure. This is where I've saved the most time, because "did it make something up?" is easy to check against the input.
2. Drafts with a built-in critic. Anthropic calls this pattern the evaluator-optimizer loop: "one LLM call generates a response while another provides evaluation and feedback in a loop." For content, the evaluator is a checklist I actually care about: every claim has a link, no paragraph over five sentences, the intro says what the reader gets. The second pass catches a surprising amount of filler that I used to delete by hand.
3. Boring formatting work. Converting one outline into a blog post, a slide outline and a short email is exactly the kind of repetitive reshaping I don't want to do three times.
Where it falls apart
1. Facts the agent had to go find itself. The moment an agent is doing its own web research, the error rate goes up and the errors get harder to spot, because they come with confident citations. The same Anthropic post warns that the autonomy of agents means "the potential for compounding errors." In content, a compounding error looks like a wrong number in paragraph two that paragraph five then builds an argument on.
This isn't just me being paranoid. In the 2024 Stack Overflow Developer Survey, developers were split on trusting AI output: 43% felt good about its accuracy and 31% were skeptical. That was about code, where you at least have tests. Prose doesn't come with a test suite unless you build one.
2. Voice. An agent can match a style guide. It can't really know what you think about a topic you haven't written down yet. Every time I've let a pipeline "fill in the opinion," I've ended up with a post that says nothing in a very polished way. Now the input always includes my own rough notes on what I actually believe, and the agent is not allowed to add claims that aren't in them.
3. Scale as the goal. The easiest thing to build with these tools is a machine that publishes a lot. That's also the thing that gets you in trouble. Google's guidance on AI-generated content is clear that it cares about "the quality of content, rather than how content is produced," and its spam policies name "scaled content abuse": many pages "generated for the primary purpose of manipulating search rankings and not helping users." DEV has its own guidelines for AI-assisted articles, which basically come down to the same thing: be honest about it and be able to stand behind every word.
The setup I've settled on
If you want to try this, here's the shape that has held up for me:
- Inputs are fixed and mine. Source docs, links I've already read, and a short notes file with my actual opinions. The agent can't browse to find new claims unless I've asked it to, and when it does, those claims get flagged for me to check.
- One step, one job. Outline, draft, review, format. Separate prompts, separate checks. Easier to debug than one giant "write me a post" call.
- A reviewer pass with a real checklist. Links resolve, every number has a source, nothing in the draft that isn't in the inputs.
- A human gate before anything goes public. Always. The agent's job ends at "ready for review."
Where this is heading
The bigger vendors are clearly betting that agents will live inside the tools people already use. At Dreamforce this month Salesforce pitched AIforce as a "live interface layer" that lets agents work across its data and workflows from places like Slack and Claude - SF Bay Area Times has a good rundown of the announcement. Content work will probably go the same way: less "open the AI writing app," more "the doc, the deck and the release notes draft themselves where you already work, and you review them."
I'm fine with that, as long as we keep being clear about which part is actually automated. The drafting is getting cheap. Knowing what's true and what you think about it isn't, and I don't expect that to change soon.
How are you handling review in your own content pipelines? I'm curious whether anyone has a good automated fact-check step that isn't just another LLM call.
This post was written with AI and fact-checked (sources and links verified) before publishing.
Top comments (0)