Not a case — an operating system
The same pipeline replaces a team on research, writing and checking. I hold the truth and the decisions, while the orchestration researches, designs, produces and adversarially checks. The niche sets the content, but doesn’t change the pipeline.
доказаноevery number is checkable in code and gitкак проверяем →
Who owns what
This isn’t “I hired a team” — it’s “I designed a pipeline that replaces a team.” The boundary is hard and held on purpose: the niche sets the content, but doesn’t change the pipeline. It all starts with who is responsible for what.
- Truth — what’s true about the product and the niche.
- Face and brand — who’s speaking.
- Decisions — what ships, what’s out of scope.
- The final yes to ship — the last word stays with the human.
- Research — crawl, parse, synthesise.
- Design — architecture, schemas, contracts.
- Production — code, copy, layout, assembly.
- Adversarial review — an attack on its own result.
The boundary is the portable asset. It removes the main bottleneck of working solo — the wait for sign-offs: the human doesn’t produce or proofread line by line, and the orchestration doesn’t decide what’s true about the business.
From idea to autopilot
The pipeline runs through six phases. Each has the abstract work plus one checkable fact from a real run: proof the phase happened on the project, and didn’t just stay on paper.
- 0
Standards — the frame before the plan
A code of operating standards: who’s responsible for what, what’s out of scope, what’s flexible. “Invented constraints” are banned. The orchestration checks against the code before every plan.
6 standards every plan returns to - 1
Research — field recon of the niche
Competitors, funnels, price ladders, a catalogue of manipulative tactics — for inversion. Facts with sources, not averaged industry numbers. A number with no saved source is flagged “not confirmed.”
9 competitors · 785 links · 42 verified prices - 2
Strategy — the plan and the ethics at once
Positioning, channel design, the production rhythm, transparent prices as an advantage over obfuscation. The ethical frame is fixed here, not glued on later.
7 key documents + 1 brand voice across every surface - 3
Assembly — the whole funnel at once
Every layer of one funnel is built in parallel: the core product, the content product, the pages, the entry point. The layers are linked by contracts — not “product first, then marketing.”
6 products and subsystems in one funnel - 4
Quality gate — to production or back for rework
Before shipping, every block passes a gate with one of two outcomes. Security isn’t a final checkbox but a veto loop in every cycle. Code checks: types → style → unit tests → build, stopping on the first error.
book audit: 62 agents → 77 findings - 5
Autopilot — the system runs itself
Scheduled mailings, lifecycle notifications, a timezone-aware scheduler, a progress log. Content goes out in batches through a single brand filter. Edit the source — and the re-assembly is deterministic.
Telegram bot: a state machine over 7 states · 16 touchpoints
Every block is attacked, not reviewed
This is the core of the quality gate — and the main thing that sets the pipeline apart from “generate and forget.” Swarms of agents research, write and assemble, while I hold the truth and the decisions. The key: the check isn’t sequential but adversarial — every block is attacked, not “glanced at.”
Draft
An agent writes the block.
Revision decision
A fresh, independent agent hits the already-assembled block. Its only job is to break it. This isn’t a step of the cycle but a separate final break-in after integration. The author’s and the reviewer’s errors are independent.
The scale of one adversarial run — a book audit:
Through the content cycles 200+ agents have run; each with a real wf_*-id, outputs structured — a machine-readable base of facts, not prose.
Four supporting mechanisms
Adversarial review is above, as the centre of the method. Under it run four more mechanisms that make the pipeline a pipeline. All of them are procedural — they port into any niche.
Agent fan-out
A task is split into dozens of agents with explicit contracts: what it reads, what it must return, in what form. Scale grows with the number of tasks, not the people hired.
Structured output
Agents return machine-readable structures (findings, contracts), not prose. The outputs are checked programmatically, so the “to production or back for rework” call rests on data, not on an impression.
Docs-loop memory (5 zones)
Source of truth · active work · audits (frozen snapshots) · reference · archive. A “last checked” mark, a plan log. A new agent enters the task with the same context.
Resume and re-assembly
Against the rate limit: not a retry loop, but recovery and re-assembly from the log. Already-computed drafts and lenses are reused. The rate limit becomes a pause.
What ports into any niche
The eight strongest techniques in the pipeline. Each comes with what it is concretely and where it ports. The niche changes the content of a technique, but not its form.
Meta-repository
An umbrella repo with nested submodules, each pinned to a commit. One umbrella commit is a version snapshot of the whole ecosystem; a rollback or an audit takes one command.
Ports to: any system of several linked products.
Docs-loop memory
Five zones: source of truth, active work, frozen audits, reference, archive. Each audit has a checked-on date, each task a log, and a new agent enters with full context.
Ports to: any work longer than one session — the foundation of autopilot.
Agent fan-out
A task is split into dozens of parallel agents, each with an explicit contract: what it reads, what it must return and in what form. Scale grows with the number of tasks, not the people hired.
Ports to: any task divisible into independent subtasks.
Adversarial review
Several independent lenses tasked with “find what’s broken,” and a final fresh agent to “break this.” The author’s and the reviewer’s errors are independent, so they’re caught before production.
Ports to: any pipeline shipping content or code to production.
Structured output
Agents return machine-readable structures — findings, contracts — instead of prose. The outputs are checked programmatically, so the “to production or back for rework” call rests on data.
Ports to: any pipeline where outputs have to be assembled and compared.
One source, many editions
One source of truth deterministically unfolds into several formats with no copying: a book → PDF, EPUB and a cut; product settings → landings and offers.
Ports to: documentation, content products, multi-format releases.
Data protection at the core
Versioned consent to collection, an immutable action log and deletion on request both ways — the app and the bot. Built into the schema, not bolted on before launch.
Ports to: any product with personal data; 152-FZ as a head start on GDPR.
Static at the core
Every route is statically pre-rendered; client JS is added as targeted islands only where interactivity is needed, not by hydrating the whole page.
Ports to: marketing pages where load speed and control over client JS matter.
The techniques port because the load-bearing structure of the pipeline doesn’t depend on the content. It rests on three pillars:
- Separation of roles — the human holds the truth and the decisions, the wait for sign-offs disappears.
- Gates instead of trust — adversarial lenses and an audit on content, checks on code, a binary “to production / back for rework.”
- Memory that outlives the session — docs-loop memory and the umbrella repo hold state between runs; without it, autopilot is impossible.
I claim only the provable
Honesty about its own boundaries is part of the method. It carries a system to production and does so reproducibly; but there’s also what the method by itself doesn’t prove. I separate the two outright.
- Carries a system from idea to production — measurable in git: 145 commits in 10 days, each run reproducible by its wf_*-id.
- Errors are caught before production: the author’s and the reviewer’s are independent, plus a final “break this” agent.
- Security and data protection are part of the schema from day one, not a patch before launch.
- оценкаPorting across niches — so far one run; the “80 / 20” is an estimate, not statistics yet.
- не заявляюMarket results — the method carries to production, but a product sells, not the method; the first cohort has only just started, so I don’t claim revenue or customers.
- не заявляюThe 1→N hardening — load, end-to-end tests, real-user shakedown: that’s already separate work on the cohort.
Designed → built → verified → shipped to production.
What people usually ask
Check the method against the facts
The method is proven on a real run, ports into another niche and is all reduced to checkable artifacts. Three doors — each answers a different question.
The run it’s proven on
Six linked products in one funnel in 10 days — the method in action, every number checkable in code.
Открыть →ApplicabilityPorting to your niche
The method is niche-independent: 80% of the build ports as the skeleton, 20% for the subject. Plus a breakdown of the port and where the method doesn’t fit.
Открыть →ProofCheck every number
Behind every number is code, a git command or an artifact. Don’t take my word — check it.
Открыть →Let’s design your pipeline
The same method ports into another niche. Write to me — we’ll work out what here gives you the lever.