How the pipeline that generates the content you’re reading actually works

Chat writes, git holds state, the server publishes: how a bus of content units grew out of scattered channel skills — and why the orchestrator no longer writes the words you read. This piece is going through that loop itself.

This is not a detached story about content automation. This article is moving through the same loop it describes: brief, evidence, canon, channel versions, checks, publication.

Under the hood, the scheme is deliberately simple: chat writes, git stores the state, the server publishes. On a whiteboard, it looks obvious. In real work, this bus appeared only because I could no longer answer a basic operational question: what state is this text in, which versions are ready, and where does it go next?

This is an engineering diary: how separate channel writers turned into one unit with a manifest; why automatic publishing to personal social channels failed in a live run; and why orchestration had to be separated from writing. Without that last cut, this article would be lying about itself.

Continue reading “How the pipeline that generates the content you’re reading actually works”

Buying Claude Licenses Is Not Enablement: What Has to Be Ready Before You Start

As of May 2026, Anthropic says Claude authored more than 80% of the code they merge into production — their figure, not a fact about your org. What it points to is real: buying licenses is not enablement. What has to be ready before you start, and how a three-layer review catches demo-grade output before it reaches production.

As of May 2026, Anthropic says Claude authored more than 80% of the code they merge into their production codebase (When AI builds itself). The number is public and it's Anthropic talking about Anthropic — not a verified fact about your organization, and it shouldn't be treated as one. But as a market signal it's worth sitting with: you probably have Claude Code licenses too, and your team is still using it as a smart autocomplete — finish a line, generate a test, speed up the boring part.

Continue reading “Buying Claude Licenses Is Not Enablement: What Has to Be Ready Before You Start”

Why AI works for everyone except certain developers

Non-technical people are outperforming developers with AI. This isn’t luck. It’s a very old principle showing up in a new context.

Something counterintuitive has been happening over the past year. The people most likely to complain that AI is "useless" are software developers. The people actually getting results? Course sellers, project managers, humanities graduates, and business analysts.

The pattern has a name.

Continue reading “Why AI works for everyone except certain developers”

The Self-Learning Agent Pattern: decisions.md + mistakes.md

AI keeps repeating the same mistakes? That’s not a model problem. It’s an engineering gap. How to give your agent persistent memory in three minutes — and why this beats RAG for most projects.

Developers complain that AI repeats the same mistakes. "I've explained five times that we don't use Redux here." "It suggested FTP again instead of a queue." "It keeps ignoring our naming conventions."

That's not a model problem. It's an engineering gap.

Continue reading “The Self-Learning Agent Pattern: decisions.md + mistakes.md”

Hiring Is Buying Delivery Leaders, Not Another AI Engineer

A one-day vacancy-intel slice: the market is buying EM/Head/CTO roles for platform and production AI — not IC seats with LLM keywords. How to read mandate, AI maturity, and founding/plant noise.

Hype counts how often “AI” appears in job descriptions. I count the mandate: who is being bought at the leadership layer, which pain the hire is meant to close, and where the feed inflates volume.

Continue reading “Hiring Is Buying Delivery Leaders, Not Another AI Engineer”

AI Is Not Just a Coder: How AI Covers the Entire Software Development Lifecycle

‘AI is just a very fast intern coder’ is an accurate description of stage one. At stage two, AI becomes an executor of thinking at every step of the SDLC — from clarify dialogs with stakeholders in Jira to multi-agent pipelines that catch, fix, and verify themselves.

"Writing code is only a small part of the SDLC. There's also stakeholder interviews, requirements formulation, architectural design, testing, monitoring. AI is just a very fast coder — not a thinking member of the team."

That argument is right. For stage one.

At stage one, someone watches AI write code and concludes: "AI = coder." Then they notice that coding isn't the whole of software development. "Therefore AI won't replace engineering entirely." The logic holds. The conclusion doesn't.

At stage two, AI covers exactly what that argument says is missing.

Continue reading “AI Is Not Just a Coder: How AI Covers the Entire Software Development Lifecycle”

How we built a hybrid reels pipeline: a real expert plus AI B-roll

The expert films the talking-head himself; the cutaways between his points are AI-generated — faceless video under synthesized speech. The story of how a one-off script grew into a five-stage pipeline, with the gotchas: hypnotic loops, ‘free’ voices that answer 402, and a Seedance that refuses to shoot 3 seconds.

The brief sounded deceptively simple: short vertical clips where a real-estate expert talks to camera, and between his points sit clean AI cutaways — construction sites, transit, a document in close-up, a phone in hand. The face is filmed by a human; the atmosphere is generated by a neural net. What started as a one-off generation script grew into a five-stage pipeline, and along the way we collected nearly every gotcha this kind of build has to offer.

Continue reading “How we built a hybrid reels pipeline: a real expert plus AI B-roll”

AI Job Demand in 2026: What Hiring Signals Show in Job Postings

Hype says “hire AI.” Job descriptions buy something else: production agents with evals and guardrails, Applied AI leadership, partner architecture, evaluation harness as a must-have. Method: read role clusters as an org chart under pressure.

Hype says “hire AI.” Real job descriptions buy people who own production agents, evals, Applied AI, and partner delivery. Below is a method for reading vacancy clusters as an org chart under pressure, plus five role clusters from a parsed corpus of open roles.

Continue reading “AI Job Demand in 2026: What Hiring Signals Show in Job Postings”

How to make eval a release criterion for AI features instead of a demo-grade approval

Demo-grade eval greenlights a feature on the same examples as the pitch. Production then shows the long tail. Three layers — incident-born regression, distribution diff vs the last snapshot, human spot-check — plus one named owner. Minimal harness: github.com/dobryakov/eval-harness.

Treat AI-output quality as a release criterion: a fixed regression set built from past incidents, a distribution diff against the previous release snapshot (20–50 real inputs), a human spot-check before the first production deploy of a new output type — and one person who signs off. Below: the demo-grade anti-pattern, the three-layer method, and a minimal harness that fails CI with a readable exit code.

Continue reading “How to make eval a release criterion for AI features instead of a demo-grade approval”

How to design professional software architecture with AI even if you don’t know the domain

Without a domain substrate, an agent ships FTP and CSV and calls it done. Book-as-context puts a book into the project as a wiki — next to LLM Wiki and book-to-skill — so a short prompt yields outbox, queues, idempotency, and fault tolerance.

Give the agent an authoritative book on the subject as a wiki in the repo — indexed and cross-linked, not a one-off file drop into the chat. Then even a short prompt designs in the source’s terms: queues, delivery guarantees, idempotency, fault tolerance. Below: the book-as-context method, a shop→ERP walkthrough, and the method’s limits.

Continue reading “How to design professional software architecture with AI even if you don’t know the domain”