The Middle Is Getting Thin
And “Intent” Becomes the New Craft
Software work used to have a clear gravity center.
You started with an idea. You ended with a shipped feature. And nearly all the effort lived in the middle: opening the codebase, setting up the environment, translating a fuzzy goal into concrete implementation.
That middle was where craftsmanship lived.
My belief (and I’m not alone here) is that this is changing: coding agents increasingly turn goals + context into working code with far less direct IDE time. The “middle” becomes thinner. Less time is spent manually translating intent into implementation.
This shift doesn’t make product work easier. It moves where the difficulty sits.
Instead of “How do we build this?”, the hard questions become:
What actually needs to be built?
What tradeoffs are acceptable?
What is the expected outcome and how do we know we got it?
Who owns the decision when agents produce a lot of output quickly?
When output becomes cheap, clarity becomes expensive.
The real bottleneck: shaping work so agents can act on it
As agents improve, they will act more directly on what we feed them: goals, tasks, context, constraints. That makes the quality of those inputs decisive.
This is why “design” in the modern sense is less about artifacts and more about forming clarity: research, exploration, discussion, and then compressing it into something actionable.
If you’ve ever watched a team struggle with a vague ticket, you already know the pattern:
unclear scope → divergent interpretations
missing constraints → accidental regressions
unclear success criteria → “done-ish”
ambiguous ownership → slow reviews and endless back-and-forth
Agents don’t magically fix that. If anything, they amplify it — because they can produce many plausible implementations quickly.
Coordination and context are becoming first-class
This is where structured tools matter. Structure reduces ambiguity for humans and agents in the same way: by making expectations and capabilities legible.
But there’s an additional pressure that shows up as the middle produces more output with less supervision: reviewing, testing, and releasing become the chokepoint.
If agents can generate PRs all day, your pipeline gets flooded:
“trust” collapses (“I don’t know if I should approve this”)
teams slow down again—just at a different stage
What tooling makes the end of the workflow as scalable as the middle just became?
The new craft: directing agent work with boundaries and proof
In the old world, the craft was implementing. In the new world, the craft is increasingly:
providing the right context
setting constraints and tradeoffs
and ensuring outcomes actually match intent
Which leads to a thesis for a new category of tooling:
We need systems that turn “intent” into an executable package for agents — plus a trustable proof for humans.
That’s the series you’re reading.
