Doubling engineering throughput with agentic coding

Give an engineer an AI coding assistant and tell them to go faster. That's the whole plan at most companies I talk to.

It doesn't work. The tool gets faster at producing diffs. It does nothing for the parts of shipping software that were never about typing speed — judgment, review, trust. I've run this differently, and the throughput gain only showed up once I stopped treating the model as the product and started treating the workflow around it as the product.

Skills, not prompts. The team's architecture conventions, its testing bar, its review checklist, its definition of done — written down, versioned, handed to every agent touching the codebase. Not tribal knowledge sitting in one senior engineer's head. Any agent inherits the same standard a good reviewer would enforce.

Deterministic gates before a human looks at anything. Full suite, lint, type-check — all green before a person spends attention on it. A senior engineer's attention is the scarcest thing on the team. I stopped spending it on things a machine checks for free.

Scoped autonomy. Not "build the feature" — "implement this interface, against this test file, touching only these directories." Autonomy without scope is how a 4,000-line diff lands in someone's queue and gets approved instead of reviewed.

Every diff ships with a short written narrative — what changed, why, what the risk is. Review starts from intent instead of reverse-engineering intent out of a patch.

And the review that actually matters happens before any code exists — on the spec, the test plan, the interface. By the time a diff lands, most of the disagreement is already resolved.

This is the skill agents invoke to ship a feature end to end:

# skill: ship-a-feature
name: ship-a-feature
description: >
  Implements a scoped feature against an existing test contract,
  respecting the team's architecture and review conventions.
constraints:
  - touch only: [src/features/${feature}/**, tests/${feature}/**]
  - must pass: [full test suite, lint, type-check]
  - must include: written change narrative (intent, approach, risk)
  - must not: introduce new dependencies without explicit approval
gate:
  - run: full_suite && lint && type_check
  - require: human_review(narrative + diff)
  - block_merge_on: any_failure

Two quarters in, three things were true.

Throughput roughly doubled against baseline. Escaped defects didn't move — the gate held the bar while speed doubled. Onboarding went from days to hours.

A new engineer inherits the same skills as everyone else now. Nobody's learning the conventions by osmosis anymore, off some senior engineer's memory of how things are done.

Here's what most teams get backwards. An agent is only as good as its context and its constraints. The skills and the gates are the real product. The model underneath is a commodity — you'll swap it more than once. Build like you already know that.