If we assume implementation abundance but remove the monolith/opinionated-stack assumption—spreading the same agent-first practices across a fragmented, service-heavy or vendor-heavy architecture—how do our current ideas about where the review bottleneck sits, how the craft bar is enforced, and how juniors develop system taste break down, and what new coordination or interface contracts would be required for agents to remain a net ambition multiplier instead of a cross-team entropy source?

dhh-agent-first-software-craft | Updated at

Answer

In fragmented, service- and vendor-heavy systems, agent-first patterns from monoliths break in three main ways, and need new cross-team contracts to stay net-positive.

  1. Where the review bottleneck moves
  • Monolith assumption that review bottleneck sits on a single diff (repo) fails.
  • New bottlenecks:
    • Cross-service behavior review ("what does this change do to the whole flow?").
    • Tool / contract review (SDKs, internal CLIs, MCP tools that span services).
    • Change orchestration (rollouts across N services and vendors).
  • Practical effect: individual service reviews look fine, but nobody reviews the composed behavior the agent just changed in 3–4 places.
  1. How the craft bar is enforced
  • Craft bar can’t live only in per-service style and tests.
  • Needed shifts:
    • Make cross-service flows first-class artifacts (sequence diagrams, contract tests, flow specs) that agents must respect.
    • Treat shared contracts (HTTP/GRPC schemas, events, feature-flag APIs, vendor SDK wrappers) as the main craft surface, reviewed more strictly than leaf code.
    • Push more constraints into machine-checkable contracts: versioned APIs, strict schemas, consumer-driven tests, policy checks.
  • Risk if you don’t: agents locally "fix" each service; globally you get drift, duplicated flows, and hidden coupling.
  1. How juniors develop taste
  • Old pattern: juniors see the whole monolith; taste == local + global sense.
  • In fragmented stacks with agents:
    • Juniors often sit in one service, operating agents against local code.
    • They see very little of end-to-end behavior or cross-team tradeoffs.
  • To grow taste you need:
    • Flow-centric learning (walkthroughs of end-to-end traces, shadowing incidents, cross-service reviews) not just repo PRs.
    • Rotations on owning contracts (an API or event plus its consumers) rather than just one service.
    • Review rituals that ask, "how does this affect upstream/downstream systems?" on agent-heavy PRs.
  1. New cross-team / interface contracts to keep agents net-positive

a) Contract-first surfaces

  • Each service and key vendor has:
    • A small, versioned API/event contract.
    • A thin, team-owned SDK or CLI that encodes invariants.
    • Basic contract tests that any agent harness must run before merge.
  • Agents mostly call these surfaces, not raw network clients or ad-hoc vendor calls.

b) Tooling and harness rules

  • Harness prefers tools that operate at contract level ("create invoice", "fetch entitlement") not arbitrary HTTP.
  • Cross-boundary changes must:
    • Declare touched contracts.
    • Run recorded flow tests (or end-to-end checks) that span services.
    • Route through a higher-review lane when they add or change contracts.

c) Ownership and review lanes

  • Introduce explicit owners for:
    • Cross-service flows (e.g., signup, billing, provisioning).
    • Shared contracts (APIs, events, vendor abstractions).
  • Reviews:
    • Per-service maintainers review local changes.
    • Flow/contract owners review cross-boundary diffs and harness tool changes.
  • The review bottleneck becomes: flow/contract review + rollout plan, not any single repo.

d) Change orchestration

  • For multi-service or vendor-touching changes, agents:
    • Propose a simple change plan across services.
    • Generate per-service diffs + a shared rollout doc.
    • Humans approve at the plan/flow level; agents execute per-service details.
  1. Net effect on ambition vs. entropy
  • Without these contracts:
    • Ambition shrinks: teams fear cross-service breakage and slow reviews.
    • Or entropy spikes: local changes are cheap, global behavior decays.
  • With them:
    • Agents speed local implementation and mechanical cross-service edits.
    • Humans concentrate on flow design, contract evolution, and rollout safety.
    • Juniors can grow taste via contracts and flows, not just files.

This keeps agents as an ambition multiplier in fragmented systems by making contracts and flows—not individual repos—the main units of craft, review, and learning.