the acceleration whiplash: what AI actually did to engineering teams
A 2026 Faros study measured AI's real impact on engineering orgs: shipping up ~66%, but incidents per PR up ~243% and review time up ~441%. The speed is real — so is the damage. The data, and what it means.
reviewing AI code one task at a time isn't enough
task-level review is mandatory. without a codebase-level strategy across tasks, you can ship a hundred correct changes and still end up with a broken system.
the last mile: why AI coding agents stop at PR open
PR open is not PR merged. The gap between them — CI failures, rebase conflicts, duplicate PRs, stuck queues — is where agent-assisted development loses its gains. Here is how to close it.
When does your AI coding agent's context run out?
AI coding agents don't announce when their context is full — quality quietly degrades. Here's how to read the signals, when to compact, and what it means when you're running agents in parallel.
AI code review that fixes instead of flagging
Most code review findings are small and obvious. Here is when an AI reviewer should apply the fix inline — and when it must loop back to implementation.
the year of harnesses
The frontier models converged, so the differentiation moved up a layer — to the harness: how work is decomposed, where a run pauses for a human, and what gets checked before code ships. On agent harnesses and harness engineering.
which agentic coding patterns actually scale
Most agentic coding patterns work on the first feature. Here is what changes as the codebase grows, the task complexity rises, or you try to share the loop with anyone else — and which patterns hold up.
getting from Step 1 to Step 2 of AI coding adoption
Most engineers using Claude Code stop at Step 1: one agent, watching every line. Here is the recipe for Step 2 — parallel agents on worktrees, self-verification loops, automated review, and the trust you build to stop reading everything.
how to make AI agents follow your CLAUDE.md project conventions
Every parallel Claude Code agent starts fresh. Here is how to get your project conventions, architecture decisions, and prohibited patterns into every agent prompt without restating them per task.
what to do with everything your AI coding agent flags
Your coding agent surfaces a stream of suggestions — tech debt, edge cases, follow-up tasks. Here are the five patterns developers actually use to handle them without building a graveyard.
when AI coding agents scope before they're ready
AI coding agents default to confident scoping even when they're missing key context. Here is what premature commitment looks like and three mechanics that change the dynamic.
configuring Claude Code for production: hooks and permissions
Most teams run Claude Code with either constant permission prompts or --dangerously-skip-permissions. There is a middle path: a settings.json with typed hooks, allow lists, and deny lists. Here is what ours looks like.
Claude Code worktrees: parallel agents without the conflicts
Running multiple Claude Code agents at once is fine until two of them edit the same file. Git worktrees are the fix — here is the practical workflow, and where the overhead still lands on you.
when your AI coding agent proposes the next task
Most AI coding agents only execute what you assign. Real development generates adjacent work mid-task. Here is how agents can surface that work for your review without going off-script.
why AI coding agents need hard stage boundaries
Two failure modes break multi-agent Claude Code workflows: stages that advance automatically, and agents that do out-of-stage work. Here is how both happen and why you need enforcement at two separate levels.
claude code skills frameworks: Superpowers vs GSD vs gstack
What Superpowers, GSD and gstack each constrain, why experienced users stack them rather than pick one, and when you'd reach for an integrated app instead.
from prompt to production: a structured pipeline for Claude Code
Running Claude Code on real features needs more than a prompt. A structured workflow — scope, design, architecture, implementation, review, release — is what keeps production output coherent.
best claude code orchestrators in 2026: an honest roundup
an honest, vendor-neutral roundup of Claude Code orchestrators in 2026 — parallel runners, spec-first tools, and the native floor — with where each one genuinely wins.
local-first ai coding: why your transcripts should stay on your machine
what local-first means for AI coding tools, the data trail an agent session leaves, who you actually pay for inference, and a vendor-neutral checklist to verify the claim.
spec-driven development, explained
spec-driven development means writing the spec - requirements, design, tasks - and correcting it before agents write code. what it is, where it helps, and its honest limits.
why 20 Claude Code instances break down (and what to do)
scaling Claude Code from 5 to 20 parallel agents crosses a threshold where qualitatively different failure modes appear — rate limits, supervision collapse, context cascade failures. what breaks, and what to do instead.
compound engineering with Claude Code: the loop, and the step everyone skips
Compound engineering — each task makes the next one easier — is the real shift in AI coding. Here's the loop, why the 'compound' step is the one everyone skips, and how to make it structural.
keeping context and decisions consistent across parallel AI agents
run several Claude Code agents at once and they drift — each has its own context window, none remembers what the others decided. what actually needs to be shared, and how teams keep parallel agents coherent.
AI didn't kill software craft. it moved it.
the worry that AI killed craftsmanship points at real grief and the wrong conclusion. craft didn't die — it moved upstream to taste and selection, and downstream to review.
you can build anything now. that's the new bottleneck.
when implementation gets cheap, the constraint moves to the front: deciding what's worth building. the scarce skill is product and business judgment, not typing.
why AI coding agents agree with everything (and how to make them push back)
LLM agents are trained to be agreeable, so they rubber-stamp your design and approve their own code. why that happens, and the tactics that get real pushback.
how AI agents onboard to a legacy codebase you've never touched
drop agents into an unfamiliar codebase and they can fix real bugs fast — if you run the right workflow. map, conventions, scoped tasks, worktrees, validation, and where it fails.
giving AI agents roles: PM, architect, reviewer, QA
one generalist agent collapses scoping, building, and reviewing into a context that reviews its own work. splitting into roles — with hand-offs and an independent reviewer — does better.
the cognitive load of running parallel Claude Code agents
running multiple Claude Code agents in parallel is technically possible today. this is what the cognitive overhead actually looks like — and why throughput alone doesn't solve it.