Traditional content marketing burns through time and budget. Writers write, editors edit, a marketing lead coordinates everything - and the cycle repeats every month. But once AI enters the picture, and someone on the team has even a bit of technical background, an obvious question comes up: why can't robots just handle this?
Marina Osborne, content marketing manager at Bitrix24, explains how vibe coding and a handful of accessible tools can build an entire content pipeline that runs with almost no human involvement.
Generating content for a website that covers dozens of modules and hundreds of features is no small task - every product update needs fresh articles, guides, and descriptions. The usual approach is simple enough: assign topics to writers, wait for drafts, send them for review, publish. It works, but once you bring vibe coding into the mix, you can go a lot further. Vibe coding is an approach where someone describes the desired outcome in plain language and lets AI write the code - which is what makes it possible to hand off routine work to robots, even without a developer on standby.
Getting a solid piece of text out of one or two prompts is basically impossible. And if you're talking about hundreds of articles a month, across different formats and topics, you need something more elaborate. The system capable of that is a pipeline of several AI agents, each handling its own stage, together covering everything from the article title to the finished, published piece.
The stack needs an orchestrator at its core - n8n works well. Topics and article statuses can live in Google Sheets, drafts in Google Docs. You'll need an LLM API (OpenAI, for instance) to generate and check the text. If you want your articles to include solid arguments backed by data, Tavily is worth adding - it pulls up-to-date research and statistics from the web. Apps Script and Python cover the automation of a few editorial tasks.
The diagram below shows the whole pipeline.
Topics and briefs - which can also be prepared with AI - get loaded into Google Sheets. From there, the first robot takes over: it identifies the article type, pulls references from a library of top-performing pieces, builds a structure, writes a draft, then a final version, trims it down to the right length, and reviews it. The draft then goes to an editor, who polishes it and makes changes. A second robot checks the edited text and scores the quality of those edits. A third robot prepares everything for publishing - layout, metadata, images, lead magnets. And the final piece: a robot that, once the article is live, automatically checks it for typos and formatting issues.
You don't need to build the whole pipeline at once, and it's actually easier to roll the agents out in a different order - start with the simplest tasks. First automate proofreading of already-published texts, then the publishing process itself, and only after that, writing and edit-quality checks. Eventually all the pieces come together into one system, so from here we'll walk through them in logical order instead.
The main character of this pipeline is the robot that turns a brief into a full draft. Getting AI to write something decent takes more than a single prompt - it's a multi-step process, and without a clear structure and reference material, the model just produces something rough. So the work gets broken into a sequence of stages.
First, the robot figures out the article type - a how-to guide, a tool comparison, a roundup of alternatives, and so on. Then it pulls from a library of top materials (built with Deep Research) and grabs three relevant examples to use as a structural reference. Next comes the outline, then a draft. After that, the system calls Tavily to gather fresh statistics and studies to weave into the text. Using the draft and that research, the writer robot puts together the full article. The next required step is compression - trimming the text down to size and cutting repetition. This matters because AI models tend to write longer than needed and repeat the same points. Then the AI checks its own finished text; if it passes, it puts together a brief for the editor with suggested fixes. If it doesn't meet the bar, or something's clearly wrong, the pipeline sends it back for another pass.
Before rolling this out, test the writer AI properly: compare articles on the same topics written by human writers against ones from the AI editor, using several models and the same scoring criteria. If the robot's texts consistently score higher, it's ready to go live.
Even so, the final draft doesn't go straight to publishing - it lands with an editor as a Google Doc. The editor builds it out further: real cases, expert examples, and an actual authorial voice.
[BANNER type="lead_banner_1" title="Master AI through these 10 prompts" content-title="Master AI through these 10 prompts" description="Enter your email to download a comprehensive list of the most essential AI prompts." picture-src="/images/content_en/articles/1-lead.png" file-path="/upload/files/Top-10-essential-AI-prompts-you-need-B24.pdf"]Commissioning a solid German-language article from scratch runs around €200. Generating the same text with AI costs 30–50 cents. Add a professional editor's pass - proofreading, fact-checking, working in real cases - at roughly €100 per article, and the AI-assisted total lands around €100.40. That's close to €100 saved per article, and with the team publishing around 17 articles a month, it adds up to roughly €1,700 a month, or a little over €20,000 a year, without cutting corners on editorial quality.
On top of the money, there's a time story too: before automation, three regional content managers spent about 30 minutes per article on formatting, metadata, and quality checks alone - work that now runs largely on autopilot, cutting that manual load by around 80% and freeing the team to focus on editing instead.
One thing an editor has to do is keep terminology consistent - especially anglicisms, which, in some markets, are legally required to be translated. Most companies keep a glossary of approved translations that needs to be followed across every publication.
Automating the whole term-replacement job with AI isn't a great idea - that kind of judgment call should stay with a person. What's worth automating is the search and the suggestions. That's what the Apps Script plugin for Google Docs does: it gets attached to every article automatically, right from the draft stage. The editor opens the document and runs the script, which scans the text. A sidebar shows only the terms that actually appear in the article and are in the glossary - each with the correct translation, and a button that highlights it directly in the text. Nothing gets replaced without the editor's say - they still decide how to fit the word naturally into the sentence, but they no longer have to hunt down the right translation themselves.
Beyond anglicisms, the same plugin can flag AI clichés - phrases like "in today's world" or "it's worth noting," the kind of language that gives away machine-written text. Building that list works well in two passes: one LLM drafts it, another checks and expands it.
This setup hits a good balance: the editor gets a tool that removes the grunt work, while keeping full control over quality and meaning.
When an editor hands back a revised text, it's worth checking, objectively, how much value they actually added. Maybe they brought in fresh cases, real statistics, integration examples. Or maybe they just reworded a few paragraphs to look busy. That's where another robot comes in - it compares the original AI draft against the edited version and produces a detailed score.
The editor uploads two files - the original and their version. The system analyzes the differences and builds a report. Thanks to vibe coding, that report can be as detailed as you want: not just highlighting what changed, but breaking down how much statistics or examples were added, how many clichés were removed, how much the structure improved, plus a score reflecting all of it.
The strongest edits can be pulled into a separate "before and after" showcase, highlighting which changes moved the needle most. That gives editors a clear sense of which techniques are actually worth their time on future pieces.
Once a piece is edited and checked, it gets published. The robot pulls the finished text from Google Docs and prepares it for the site:
converts it to clean HTML
generates meta titles and descriptions for search results
adds call-to-action blocks, assigns a category, and builds an SEO-friendly URL
picks preview and in-article images, including product screenshots
It also builds lead magnets - PDFs that readers get after subscribing by email.
The end result is one CSV file, ready for bulk upload into the site's admin panel.
The next step is teaching the publishing robot to generate infographics, plus create and bulk-upload audio versions of articles.
As soon as a new piece goes live, a proofreader robot picks it up for a final pass. It runs two layers of checks. The first is code-level: scanning the layout for technical issues - stray spaces, broken line breaks, weird characters, dead links, that sort of thing. The second layer is a language model checking spelling, grammar, and any stray characters from the wrong alphabet that slipped in.
Even once the system is fully up and running, there's room to push further. Three directions tend to get the most attention.
The first, and most ambitious, is an analyst agent that aggregates data on editors' changes. That analysis could feed back into prompts, rules, and generation logic - the goal being drafts that get closer to what a human editor would produce, cutting down the editing workload over time.
The second is expanding what the publishing robot can do - infographics, and eventually audio versions of articles with automatic bulk upload.
The third is smaller, ongoing fixes to the agents already in place. For example, teaching the publishing robot to automatically add nofollow tags to outbound links, if that used to be done by hand through the admin panel. These kinds of tweaks show up regularly as new bottlenecks get spotted.
Vibe coding works, but it takes time. Building a pipeline like this takes around six months of steady iteration. A couple of prompts won't cut it - every stage needs ongoing tuning. A marketer with some technical background can pull this off solo. Without that experience, vibe coding still helps by making it easier to talk to developers and speeding up the build.
Multiple stages beat one big prompt. Writing, compression, and review need to be separate steps, each with its own model and its own job.
People stay in the loop. AI isn't replacing editors - it's taking the routine work off their plate so they can focus on what actually needs a human: cases, expertise, style.
Lean on your best material. Using your own library of strong content as reference and context makes a real difference - it gives the system a structure and logic to aim for.