How to Build an AI Stakeholder Alignment Machine

Alignment isn’t a conversation, it’s a dispatch algorithm. Here’s how to build a multi-agent system that routes questions, resolves conflicts by seniority, and gives you a counter that hits zero.

Alignment looks like a conversation. It isn't. It's a dispatch algorithm — routing traffic between people until a set of open questions hits zero. Humans have been running this algorithm manually for decades, badly, because there was nobody to hand it to. Now there is.

What follows is a construction of several agents and tools that drive project alignment without you in the loop: it finds holes in the spec, routes questions to people through channels they actually use, processes answers, resolves contradictions by seniority, and stops either at zero open questions or at an escalation to a human. Stakeholders, adjacent teams, contractors — the mechanics don't change.

Continue reading “How to Build an AI Stakeholder Alignment Machine”

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”

Hierarchy Is a Contract, Not Oppression

Why people instinctively seek strong leaders, why managers avoid building hierarchy, and what happens when there’s no formal structure — the tyranny of structurelessness.

The most successful "flat" organizations I've encountered weren't actually flat. Someone was making decisions. Someone was absorbing pressure. Someone was the de facto leader — without the title, without the accountability, and without the legitimate authority that would have made the whole thing transparent and fair.

Continue reading “Hierarchy Is a Contract, Not Oppression”

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”

The Employment Theater of AI Code Review

3 AM. A senior developer stares at the monitor, eyes red. On screen: a massive diff. The AI generated five hundred lines of code in three seconds. Now our hero is spending half an hour reading every single line — checking brackets, variable names, indentation. In their head: "This is real engineering work."

From the outside — surrealist tragicomedy: the AI spent a moment, the human spent thirty minutes reading the output. Meanwhile, this same developer refused to spend five minutes before running the model to write clear acceptance criteria, boundary conditions, and an automated test that would verify the code in milliseconds.

The pattern is everywhere.

Continue reading “The Employment Theater of AI Code Review”

The core role of people in software development is over

Try getting a development team to consistently write tests before every commit. Not "agree in principle" — actually do it, without reminders. Or document their code. Or have a senior engineer support code three juniors wrote six months ago.

If you've never managed developers, this sounds like a process problem. If you have — you understand why what I'm about to describe doesn't surprise me anymore.

Continue reading “The core role of people in software development is over”

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”