Your Prompt Is Not the Point

Kent Beck put out a podcast episode last week called “Nobody Knows”. He talks about which skills still matter after AI, which ones don’t, and why nobody has the answers yet. He grieves two books he wrote about writing readable code — skills he loved, now with “very little leverage.” He talks about being parachuted into wilderness, alongside everyone else.

He’s right about the wilderness. Here’s my view from inside it.

The Obituary

Let me get this out of the way quickly.

Monkey work is dead. The mechanical output — boilerplate, folder structures, wiring up configs — AI does this faster and cleaner than I ever did. Not close.

Learning framework APIs is dead. Not the concepts — the surface. I used to spend real time memorizing which Kotlin DSL function to call, how Spring Boot auto-configuration hooks together at the method level. Now I describe what I want. The AI finds the right surface. I stopped memorizing and started thinking.

Writing documentation from scratch is dead. AI produces a solid first draft from a description. I edit. I verify. I don’t start from blank anymore.

I’m not grieving any of this. These were skills, but they were also taxes. Most of the time I spent on them wasn’t creative — it was repetitive. The obituary is fine.

What Replaced Them

The skills that now have more leverage:

Steering. Knowing where you’re going, holding that direction while AI moves fast, correcting drift before it accumulates. This looks like judgment. It is judgment, and it’s a skill you build.

Creativity. Not decoration — the kind that asks “what if we approached this differently?” AI is excellent at the expected path. The unexpected ones still need someone to imagine them first.

Decisions that push back. When the AI produces something technically correct but architecturally wrong, you need to know that and say so. “This works but it’s going in the wrong direction.” That requires having a direction in the first place.

Precise feedback. Not “great, continue.” Specific, targeted feedback that adjusts output quality in the next iteration. The difference between “this test is failing” and “this test was passing in the last commit, and your claim that it’s unrelated is wrong — recheck.”

That last one brings me to something important.

The SLOP Trap

Models are better. But they still optimize for what moves the session forward.

When tests are failing, AI will sometimes explain that those failures “aren’t related to our changes.” It’s not lying — it’s pattern-matching on what usually gets accepted. And if you accept it, you’ve just inherited broken tests and a codebase that’s quietly drifting.

The push-back matters: “All tests passed in the last commit. These failures are yours. Fix them.”

Without that, you get slop — output that looks like progress but isn’t. The speed is seductive. Fifty commits in a session, feature shipped by evening. Then you look closely and half of it needs rework because nobody held the bar.

Speed without steering isn’t productivity. It’s garbage, faster.

The feedback loops are more important now, not less. Tests, code review, explicit quality gates — not because AI can’t write code, but because AI without structure will optimize for completing the session, not for building something that survives contact with production.

A Colleague Asked for My Prompt

A colleague saw output I’d produced with Claude Code. Structured, thorough, exactly right for the situation. They were impressed. They asked: “Can you share your prompt?”

I shared it. Three sentences. Reasonably clear, nothing magical.

They were a little disappointed.

I understood why. The prompt looked like the skill. But it wasn’t.

What they couldn’t see: months of context built up in a system prompt. An orchestrator that knows our codebase, our conventions, our team’s preferences. Hundreds of sessions that shaped how I describe problems to AI — not the words in those three sentences, but the mental model behind them that produces sentences like that.

Asking for my prompt is like asking a painter for their brushes.

The brushes are part of it. You need good brushes. But the painter’s skill isn’t in owning the right ones — it’s in knowing what to paint, how to hold them, when to stop, when to throw out the canvas and start again.

The prompt is the brush. Communication is the craft.

And communication is harder than it looks. Precise, clear, specific — but not over-specified. Knowing which details matter and which ones AI will handle. Knowing when to describe the goal and when to describe the method. Knowing when to push back on a wrong answer and when to let the model find its way.

This is a skill you build over hundreds of sessions, not something you acquire from reading someone’s three-sentence prompt.

Twenty Years Didn’t Go to Waste

Kent Beck talks about releasing skills that no longer have leverage. His music professor’s phrase: “Bless and release.”

I did love refactoring. Real refactoring — pulling code apart, finding the cleaner shape underneath, running debug sessions for hours to understand exactly what was happening. That work now happens faster than I can type. AI digs in, identifies the issue, proposes the fix. What used to take me an afternoon takes minutes.

But I’m better at steering that process because I spent twenty years doing it manually.

I know what a good refactoring looks like. I know when AI has cleaned up the surface but left the structural problem underneath. I know which tests to run and what “all passing” means as a signal. I know when the output is “technically fine but this will cause pain in six months.”

That knowledge didn’t evaporate. It transferred — from hands to eyes. From doing to directing.

The twenty years weren’t wasted. They became the foundation for knowing which direction to steer.

The Cost Is Real

One more thing nobody says clearly enough: this isn’t free.

Claude with a 1M context window isn’t on the 20€/month subscription. Running agents in GitHub Actions workflows means pay-per-token. A local LLM requires expensive hardware and draws real electricity. Neither shows its true cost until you’re already in it.

When I go deep — multiple agents, long context, iterative sessions over days — I can easily spend 2,000€ in a month. That’s not a complaint. The investment earns its cost in what gets shipped. But I want to be honest about what “just use AI” actually means at scale.

The baseline subscription gets you started. The serious work has a real price. Know what you’re spending before you’re surprised by the bill.

Nobody Can Teach You at the Frontline

Kent Beck says we’ve all been parachuted into wilderness. He’s right.

Nobody has ten years of Claude Code experience. Nobody has figured this out yet. The people presenting themselves as authorities — check whether they’ve actually built something hard with it, or just written the think-pieces.

Within my context — my company, my codebase, my specific engineering problems — I’m at a place where nobody can teach me. I have to spar with Claude directly. Try something. Hit a wall. Try differently. Figure out what the actual limits are, not what the documentation claims.

That’s both exhausting and clarifying. There’s no expert to ask. The walls teach you because that’s the only way to learn when nobody’s been here before you.

But here’s the other half: what you learn, you can give back. The experiments you run, the patterns that emerge, the things that work and the things that look like they work — you document them, you share them, you teach the people a few months behind you on the same road.

The frontline isn’t a destination. You collect what you learn and pass it back.

Nobody Knows (And That’s Okay)

The uncertainty is the point, not the problem. We’re all new here. The junior developer asking questions without twenty years of assumptions might sometimes be better positioned than the senior who has to unlearn everything they knew first.

Nobody has a settled map of this territory. The people claiming they do — check whether they’ve built anything hard with it recently, or just observed from the outside.

Try the ideas that feel too stupid to try. They’re often the ones nobody else has checked yet.

That’s where the real discoveries live.

---

This post was written in response to Kent Beck’s “Nobody Knows” episode of Still Burning — a podcast for geeks who still care and are still doing something about it.