«AI Writes Code, but a Human Still Has to Run the Project» — No. The Entire SDLC Runs on Agents Now

Requirements, planning, infra, CI/CD, tests, monitoring — every step of the cycle, pinned to a specific tool and a production case. No human in the loop required.

I read this opinion ten times a week. Okay, the argument goes, AI can write code — fine. But to actually run a project, you need a human: talk to stakeholders, write a plan, set tasks for that same AI, configure infrastructure, Git, servers, monitoring. And surely no one is replacing the human there!

My eyes roll back every time. What?

Let me walk through the entire cycle. Step by step. At every step, I will show you not a fantasy, but a specific practice with a tool underneath it — because I have already run this cycle hands-on.

Continue reading “«AI Writes Code, but a Human Still Has to Run the Project» — No. The Entire SDLC Runs on Agents Now”

Enabling Blocks Network inside a conservative enterprise — the plumbing you have to build before an agent network is even allowed

An enablement playbook for a large, risk-averse, vertically integrated company — mapping the internal estate, naming the systems you won’t crack first, and building the egress, identity, façade and audit layers that turn “nice demo” into “approved pilot.”

The easy version of "adopt an agent network" is a demo on a laptop. The hard version is the one that pays: getting that network approved, piloted and scaled inside a big, conservative company that has a lot to lose.

Picture the archetype. A vertically integrated manufacturer-retailer: its own factories, its own warehouses and trucks, its own stores, its own contact centre. The IT estate is mature but heavy — an ERP at the core, a patchwork of line-of-business systems around it, home-grown glue holding the seams together. There is a security function with veto power, a procurement function that owns the contract, and a culture whose first instinct is "prove this won't break sales during peak season."

This is a playbook for that company. Not the marketing pitch — the actual sequence of questions you get asked, in the order you get asked them, and the honest answer to each. I'll keep the vendor's claims, the things I verified in a build, and the things that are spec-only strictly separate, because in a room like this, blurring them is how you lose the room.

Continue reading “Enabling Blocks Network inside a conservative enterprise — the plumbing you have to build before an agent network is even allowed”

Building on Blocks Network — a hands-on field report on the “Internet of Agents”

Two agents, one live agent-to-agent call, and an honest engineering read for developers, DevOps, analysts and security teams.

Every team I work with is suddenly shipping AI agents. The agents are the easy part. The hard part — the part I spent years solving for ordinary services — is the layer underneath: how does an agent built by one team get discovered, called, and governed by another, without everyone rebuilding the same plumbing and without security signing off on a free-for-all?

Blocks Network (from PubNub) pitches itself as exactly that substrate — a network for agent-to-agent communication with routing, discovery, presence and an economy layer. So instead of reading the marketing, I built on it. This is a field report from taking it from npm install to a live two-agent call, written for the four people who actually have to approve this kind of thing: the developer, the DevOps/platform engineer, the analyst/architect, and the security reviewer.

Everything below is what I observed on the real platform on a Linux box (Node v20.19.5, Blocks CLI 1.0.24). Where I couldn't verify something, I say so.

Continue reading “Building on Blocks Network — a hands-on field report on the “Internet of Agents””

How to Put a System One Classifier at the Pipeline Entrance

A cheap classification layer at the pipeline entrance changes the economics of the entire conveyor. One call turns raw records into labeled facts — every downstream step reads fields instead of re-extracting meaning.

Every data pipeline starts the same way: a stream of raw records lands at the entrance, and the first thing you need is to figure out what each record actually is. What type, what format, what attributes, whether it's worth spending expensive downstream steps on. At this point, teams usually pick between two bad options: hand the work to a large language model — expensive and slow on every single record — or hardcode it into regexes and heuristics — cheap, but brittle and blind to meaning.

A third option appeared recently: System One models. I spent time with one of them, Jev from TypeSafe, and the conclusion I want to lock in is this: the most valuable place for such a model is not somewhere in the middle of the pipeline. It is at the very entrance, as a labeling and enrichment layer.

Continue reading “How to Put a System One Classifier at the Pipeline Entrance”

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”