The math changed. So did what you're paying for.

Stripe merges 1,300 agent-written pull requests a week, human-reviewed, none human-written. Anthropic says 80% of its new production code is written by Claude. In 1975, Fred Brooks argued that adding people to a software project doesn't make it faster, and we ran headcount math anyway for fifty years because there was nothing else to buy. That assumption just broke, and I spend this week's video working through what actually changed.

Watch the video →

Brooks also described a "surgical team": one senior engineer doing the real work, backed by a copilot, a toolsmith, a tester, and a clerk so the surgeon's focus never breaks. He liked the idea. The economics killed it, because ten salaries supporting one mind never penciled out. Fifty years later, that team is finally affordable, just built from agents instead of headcount. Gartner is now predicting 60% of organizations will run smaller engineering teams by 2029. That's not a hiring freeze story. It's a re-pointing of what a team is built to do.

Agents absorbed a narrower, more specific band of engineering work than the headlines suggest. Scaffolding, test coverage, routine refactors, documentation: agents draft all of that faster than a human typing it line by line. Architecture calls, risk tradeoffs, security decisions, and the choice to ship or hold stayed exactly where they were, with a human who owns the outcome. What moved is the bottleneck. Median time to first PR review is up 156.6%, across two years of telemetry from 22,000 developers, because verification, not generation, is now the expensive step. You can generate ten times the plausible-looking code. Someone still has to decide which of it is actually right.

That's the same argument underneath this week's post on fractional CTO pricing, just seen from the buyer's side instead of the builder's. Entry-level fractional CTO work still starts around $2,999/month for lighter oversight, the mid-tier where most engagements land still runs $5,000 to $15,000/month for hands-on architecture and review work, and a full-time hire still costs $250,000+/year before equity and search costs. The price range didn't move, because judgment never got cheaper. Agents just made it possible to apply that judgment to ten times the output, at the same rate you used to review one time's worth.

Read what that means for pricing, and which tier actually fits your team →

Contributor Spotlight: Greg Wilson

Starting with this issue, Greg Wilson is joining Practical AI as a contributor. He builds production Mastra agents and writes exactly the kind of ground-level operational detail this newsletter is for. You'll see his byline here periodically.

His first pick: Export Mastra agent metrics to Prometheus. Greg walks through getting Mastra agent metrics, latency, tokens, cost, straight into Prometheus without standing up a separate OLAP store like ClickHouse or DuckDB. He hooks into Mastra's ObservabilityExporter, turns duration into histograms and token counts into counters, and attaches trace IDs as exemplars so a P95 latency spike in Grafana links straight back to the exact trace that caused it. If you're already running Prometheus and want to alert on agent behavior instead of just watching a Studio dashboard, this is the shortest path there.

Curated Links & Tools

Career advice in the age of AI — Phil Chen (Scale, DeepMind, OpenAI, now building an agent-native startup) makes a sharp argument: AI gets better at anything with a loss function, and school is mostly loss functions, well-defined problems graded against known answers. So the durable skill isn't solving the assigned problem, it's finding the right one to solve, and knowing when to allocate tokens and time to it. It's the same judgment-over-execution argument as the pricing post above, aimed at hiring instead of retainers.

A Field Guide to Fable: Finding Your Unknowns — Thariq Shihipar's framing of "unknowns" when working with Claude Fable is one of the more useful mental models I've read for scoping any agent task: known knowns (what's in your prompt), known unknowns (what you're aware you haven't figured out), unknown knowns (what's so obvious you'd never write it down), and unknown unknowns (what you haven't considered at all). His prompt patterns for surfacing each one, blind spot passes, brainstorm prototypes, implementation-notes files, are worth stealing directly.

What's the last technical decision where an agent could have produced the code, but you were still the one who had to decide if it was right? Reply and tell me.

If you're rethinking what a fractional CTO engagement should look like now that the math has changed, that's exactly the work I do. Here's how I help →

Damian