Agentic Engineering and the Creativity You Stop Growing
Agents build the product and absorb its context. The model never forms in your head, so when creative judgement is needed there's no seed to grow it from.

A product is a picture in your head before it is anything else.
Six months into a client build, we were on a call about what to do next, and someone asked a question I should have been able to answer in one breath: if we change the way this step hands off to the next one, what else moves?
I knew exactly where to look it up. I did not know the answer.
The system worked. I had designed it and shipped it with my name on the delivery. Most of it had been written by an agent with me steering, which is how I work now and how I plan to keep working. But somewhere between the proof of concept and the thing we were trying to extend, I had stopped being the person who could hold the whole of it at once. I could operate it. I could not drive it.
I wrote about one half of this in The Hidden Cost of Vibe Coding: the memory you never build for a system you didn't write, and what it costs when something breaks. This is the other half, and for my work it's the more expensive one. It's about inventing what comes next.
I design the first version of a client's solution, build it, and I'm still there when it meets reality. The role has a name now, the forward deployed engineer, and what defines it is that the person who maps the problem on day one is the same person on the call when it bends in month six. So the proof of concept was never only a deliverable. Building it by hand was how I learned where the data is actually dirty and which requirement they said out loud but didn't mean. It was my apprenticeship to the problem, and I happened to get paid for it.
That's the phase I have now handed to an agent.
The tree
There's a sketch in my notebook from this summer that I keep coming back to. Creativity as a fruit tree. The fruit is what everyone sees: the features, the clever piece of product that makes a client sit forward. Underneath it sits a whole apparatus nobody looks at. A seed, roots, vessels carrying things up the trunk.
What most of us get backwards is thinking the tree produces fruit. It doesn't. It creates a situation in which fruit is possible.
There's a lab version of that. When researchers tested whether sleep produces sudden insight into a hidden rule, more than twice as many sleepers cracked it. Then comes the qualifier: sleep did not enhance insight in the absence of initial training (Wagner et al., Nature 2004). The idle cycles I've written about before are real. They run on material you already put in.

The pattern tracks how involved I was at the start
What convinced me wasn't that one call. It's that the same thing keeps happening, and it happens in a specific place.
I'll be deep in a prototype, we'll reach the point where somebody needs an idea, and there's nothing there. Not a wrong idea. Nothing. The well that normally holds three bad options and one interesting one is dry.
The times that happened share a shape: most of the work had already been done without me. In one case a skill went off and assembled the whole context by itself, the Slack threads and the Notion docs, and came back with code that looked genuinely good. It was good. Better than what I'd have put together by hand, and it arrived without passing through me. Nobody needed me to read any of it, so I didn't. Then we wanted to extend it, the part of the work that needs a judgement call showed up, and I had no seed to grow one from.
Set that against the projects I was inside from the first week. More in control, and more creative, and I've stopped thinking those are two separate things. It's the same person in the same year with the same tools. The only variable that moved was how much of the early context went through my head.
Which is the thing I'd most want someone to take from this. The apparatus gets grown in the phase that's now cheap, and it gets spent in the phase that's still hard.

It's recollection, though, and recollection grades its own homework. The projects I threw myself into were probably the ones I already found interesting, which is its own reason to feel creative in them. What I have is a pattern in my own work, not a result. So here is what the people who measure things have found.
Reframing is the creative move, and it's where the help stops
Creativity in solution engineering isn't a novel algorithm. It's noticing that the problem the client described isn't the problem they have, or that the expensive half of the system doesn't need to exist.
Design researchers have been describing that move for decades. Horst Rittel put it hardest in the paper that named wicked problems: the problem cannot be understood without solving it (Rittel and Webber, 1973). Donald Schön described the loop as a conversation, where you make a move and the situation talks back with a consequence you didn't predict, and that back-talk is what makes you reframe (Schön, 1983).
Now put an agent in the middle of that loop. The moves get made and the consequences get handled, and the surprises land in the agent's trajectory rather than in your head. What reaches you is a summary of a resolved state. You inherit a solution and skip the problem.
The measurements point the same way. When researchers watched people do real feature work in an existing codebase with an AI assistant, the ones who gained the most speed understood the result least: a correlation of −0.57 between someone's speed-up and how well they could explain code the model had written for them, with comprehension of the parts they specified themselves trending the other way (Qiao et al., 2025). Fifteen graduate students isn't a fleet of professionals, and I cite it because it's the closest anyone has come to measuring this. On reframing the evidence is firmer: across 280 designers and three different ways of using a model, LLM help produced no improvement in the novelty or usefulness of the problem frames people generated, while widening the gap between the more and less capable (Shin et al., CHI 2025).
A working product is not a good product
One line from that same summer I'd put on the wall of every AI project I've been near this year.
A working product and a good product are not the same thing.Working is a property of the artifact. Good is a judgement about a person's problem, made by someone holding a model of that person. Agents are extremely good at producing working. They have no opinion about good, because good isn't in the artifact.
So the useful question stopped being how much I can delegate. It became which parts I refuse to. Implementation I hand over without much hesitation. The two ends are what I've started guarding: understanding whose problem this is at the front, and deciding whether the thing is actually good at the back. Architecture sits in the middle, and that's where I've been losing ground without noticing.
What would make me wrong
There are explanations for that call that have nothing to do with my head. Model help is jagged rather than uniform: in a controlled study of consultants, the same tool that made people meaningfully better inside its range made them substantially worse on the one task that sat just outside it (Dell'Acqua et al., 2025). And the largest synthesis of human-AI work cuts both ways. Across 106 experiments, human-AI teams did worse on average than whichever of the human or the AI was better alone, but clearly better than a human working alone, and on creating things their gain wasn't statistically significant (Vaccaro et al., Nature Human Behaviour 2024). My claim is about creative work, and that's exactly the cell where the evidence is thinnest. Nobody has run the study I actually need, where the same ill-structured problem is developed either by you or for you and then your understanding of it is measured.
These effects also look like properties of how you use the thing rather than properties of the thing. A tutor that gave answers damaged learning and a tutor that gave hints didn't, using the same underlying model. That's the whole lever.
Keep your hands in the soil
I'm not going back. I'm agentic every day, I'd be slower and narrower without it, and the enablement is real in the way I described when I wrote about riding enabled rather than borrowed.
But I've stopped believing the scaffolding phase was ever just scaffolding. It was where I grew the thing everything else hangs off, and I automated it without noticing what else was in the box. Same with the reading. When something assembles the context for me, what it saves me from is what was building the seed.
So the practice I'm trying isn't heroic. Build the first one of anything genuinely new by hand, then let the agent replicate it. Read the raw material yourself at least once, even when a good summary is already sitting there. And predict what a change will touch before you read what it touched, because being wrong on purpose is the only thing that updates the map.