Journal

A 2025 randomized controlled trial from METR found experienced developers were about 19% slower with AI tools, while they believed they were faster. The gap between the feeling and the measurement is the real risk, and it's a management problem before it's a tooling one.

GitClear analyzed 211 million lines of code and found that as AI tools spread, copy-pasted code overtook refactored code for the first time. The speed is real. So is the maintenance debt it quietly defers, and that bill comes due on your team, later.

A Stanford study of 100,000+ developers found AI delivers big gains on clean, greenfield work and almost none on the complex, legacy code where most teams actually live. The lever isn't the model. It's the state of your codebase, and that's something you can change.

Six independent studies, from METR, Stanford, Apple, Google's DORA, GitClear, and ETH Zurich, converge on one finding: AI coding tools don't improve software on their own. Adoption is not improvement. The gains are real but conditional on the operating model around the tools. Here's the evidence, with sources.

Google's 2024 DORA report found that as teams adopted AI, delivery throughput and stability went down, not up. The culprit isn't bad AI code. It's batch size: AI removes the friction that used to keep change sets small, and big batches break delivery.

AI coding agents don't fail randomly. They fail in a handful of predictable, nameable ways, and every one is an engineering problem with a known fix, not a model that isn't smart enough yet.

A 2026 ETH Zurich study found that adding repository context files to coding agents usually makes them worse and more expensive. The lesson isn't 'no context.' It's the right context, which is a harder engineering problem than writing a long AGENTS.md.

The fear with a studio that builds fast with AI is that you get demo-grade software. You don't, if production is the method and not a finishing step. Here's where the speed comes from, and why the bar holds.

A dev shop hands you a codebase and an invoice. An agentic studio builds your product the way you'll eventually run it: agent fleets in production, your standards, your repo, no lock-in. Here's the difference.

Most teams scale their AI coding agents right after the demo works, which is the wrong moment. The signal to scale isn't enthusiasm. It's that the constraints keeping solo agent use safe have started to break across the team.

Most 'AI assessments' are a slide deck or a readiness quiz with a sales call attached. A real one happens in your repo, in production, and tells you what AI won't fix. Here's what it is and what you keep.

Most teams ship agent changes on vibes: it felt better in the demo. But an agent silently regresses, and \"it seems good\" isn't a measurement. Evals are a golden set of real tasks with gradeable outcomes, run on every change, with the judge itself checked.

The moment you give an AI coding agent tools, prompt injection stops being a content problem and becomes remote code execution. The agent reads a poisoned repo or issue, and the injected instruction runs with the agent's permissions. You don't prompt your way out of this. You treat the agent as an untrusted client.

\"AI reads your documents\" dies on the boring parts. Replacing a legacy DMS isn't a chatbot over your files. It's a split-classify-extract pipeline that has to beat the humans it replaces across an 89,000-document backlog and 142 real categories.

The license tag on an open-weight model often isn't the license you're actually bound by. Licenses inherit through fine-tunes, and the tag inherits wrong all the time. Ship on the tag and you can be running a restricted model in production without knowing it.

Your best senior tried the AI, got code that was almost right and took longer to fix than write, and quietly stopped. That's not resistance, it's judgment. Here's how a lead earns real buy-in instead of fighting it.

One agent needs no coordination. Five do. Run them in parallel without it and you get collisions, duplicated work, and a handoff loop where nobody owns the task. Orchestration is the discipline that turns a pile of agents into a team.