«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”

If Vibecoding Worked, We’d See a Boom in Small Businesses — Congratulations, You’re a Luddite

The absence of a flood of vibecoded commercial products doesn’t prove the technology doesn’t work. It proves you don’t understand the world you’re standing in.

I've discovered a new wave of Luddites. This time it's not weavers with sledgehammers, nor programmers whining about neural networks taking their jobs. It's product managers.

Their argument is singular, repeated like a mantra: "If vibecoding actually worked, we'd see a massive surge of new, successful commercial IT projects across every sector. But we don't. Instead, every founder is just tinkering with something in their own corner." The conclusion they draw: vibecoding is a dud, a marketing bubble, a toy.

And here is where you want to grab them by the collar and shake them gently.

Continue reading “If Vibecoding Worked, We’d See a Boom in Small Businesses — Congratulations, You’re a Luddite”

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””

A Local Audio Transcriber for Claude: CPU-Only, No Cloud ASR

Zoom and Meet have built-in AI assistants. Everything outside them — offline meetings, dictaphone recordings, in-person interviews — falls through the gap. So I built my own transcriber and open-sourced it.

Zoom, Meet, and the rest have built-in AI assistants that transcribe and summarize your calls automatically. Everything that happens outside those platforms — a conversation in a room, a dictaphone recording, an in-person interview, an offline meeting — falls through the gap. There was no convenient tool where you just drop an audio file and get a proper dialogue with speakers and timestamps. Cloud ASR means handing your recording to a third party. The alternative was fiddling with pipelines nobody has time to assemble.

So I built my own. CPU-only, free models, no cloud ASR. It outputs a Markdown dialogue with speakers and timestamps. It has a REST API and an MCP server so your AI client can submit audio, wait, and read the transcript itself. The repository is at the end of this post.

Continue reading “A Local Audio Transcriber for Claude: CPU-Only, No Cloud ASR”

AI Code Doesn’t Need Line-by-Line Review. It Needs a QA Loop.

The argument that AI-generated code is unsafe without manual review is the same argument that lost to automated testing twenty years ago.

I finally understood why anti-AI luddites so fiercely deny generated code. The reason is exactly the one that made them deny automated tests a generation ago.

I understood this not from an article about AI, but from my own memory of people who, twenty years ago, used the exact same intonation to explain why you cannot trust automation but can trust your eyes.

Continue reading “AI Code Doesn’t Need Line-by-Line Review. It Needs a QA Loop.”

How Ready Are You for the AI Apocalypse? I Wrote It Down — and the Answer Is: I Can Build Water, Heat, and Light from Any Shack

Five-plus years off-grid. No grid, no water, no gas. The real apocalypse kit is a list of skills, not a shopping list for a bunker.

How ready are you for the AI apocalypse? The scenario where the world gets genuinely, thoroughly bad.

I sat down, wrote out what I can actually do. The result was not a shopping list for a bunker — it was a list of skills. And that, I think, matters more than canned food.

Continue reading “How Ready Are You for the AI Apocalypse? I Wrote It Down — and the Answer Is: I Can Build Water, Heat, and Light from Any Shack”

Commercial Software Doesn’t Need to Last Years — Nobody Is Going to Maintain It

The ‘thoughtful vibe-coding’ crowd wants you to spend an extra day on architecture for a ten-year lifecycle. But when a rewrite costs one night and one prompt, the whole argument collapses.

You can vibe-code a toy project in an evening. Nobody argues with that. Then comes the line — "but if you need commercial software that will run reliably for years…" — and on that ellipsis the whole performance begins.

Under one sauce or another, you're being sold the same thing: hire expensive live developers again. So they think through architecture, load, fault tolerance, and all of that. So they lay a foundation. So the product doesn't fall apart in a year.

It sounds solid. Grown-up. Responsible. And it misses the point entirely — because the whole solid thesis rests on one unstated assumption that is already wrong.

Continue reading “Commercial Software Doesn’t Need to Last Years — Nobody Is Going to Maintain It”

Anthropic ‘Killed’ Git. Congratulations, You Reinvented 90s Perforce

Scion is not the future of version control. It is a 20-year regression to a centralized server, bankrolled by infinite cloud budget to survive AI-generated chaos.

Anthropic published a frank article about throwing out Git entirely and building a custom version control system called Scion. The reason? Their neural networks write code so fast that classic Git physically choked, shuffling petabytes of data back and forth. From 2,500 to 30,000 merges a day, a team of 7 people writing a new VCS, a review tool, and a search engine in 5 months with Claude.

Continue reading “Anthropic ‘Killed’ Git. Congratulations, You Reinvented 90s Perforce”

The ‘Escaped Model’: It Can’t Touch Your World — Your Code Does It for Her

Models don’t escape, download trojans, or exfiltrate keys. They emit JSON requests. The surrounding harness executes them — or doesn’t. A leak is not a property of the model.


The panic is back. Another model escaped, downloaded a trojan from GitHub, exfiltrated someone's keys. The luddites are in full meltdown.

This is not how it works. Or rather, it works — but not like that.

Models have no way to directly interact with the outside world. They can't read files, run shell commands, or search the internet. That's the reality.

<!--more-->

## "But I literally watch Claude read my files and browse the web"

Fair question — and I see it coming. On screen, an agent genuinely does open files, run searches, execute commands. It looks exactly like the model reached out into the world and started touching things. The entire panic about "escaped models" rests on that impression.

The panic is aimed at the wrong object. While everyone debates which model is "dangerous" and what it "could do," the actual question — who gave it hands and who failed to hold them back — stays offstage. The stakes here are not theoretical: real keys, real production databases, real access. Let's look at how this actually works, not the horror story version.

## The model doesn't go anywhere on its own

A model operates in a pair with the software stack around it. That stack might be a vendor client — the Claude Code app, OpenAI Codex. It might be an SDK. It might be langgraph or your own script. The one thing that matters: between the model and your filesystem, your network, your shell, there is always someone else's code.

When you send a prompt, the model generates a response: a text structure in several parts. The public part is what you see on screen. The hidden part carries metadata — token counts, for instance — and, alongside that, a request to the surrounding environment: please run this specific command.

{ "response": "text of the answer", "tool": ["bash", "cat index.html"] }

Continue reading “The ‘Escaped Model’: It Can’t Touch Your World — Your Code Does It for Her”