The Inner Game of CHOP
Prompt (Bounce) → Review (Hit) → Refine → Repeat
The cursor blinks steadily in the AI chat window, patient and waiting. After years or decades of programming, here I was, and here you are hesitating to type. Not because its not clear what to build but because of the battle raging inside your mind.
"Just write it yourself," hisses your inner critic. "That's what real developers do."
If you're reading this, you know the voice.
I call it my Traditional Developer Self, but in "The Inner Game of Tennis," they call it Self 1. It's the voice of experience, of control, of "proper" clean coding practices. And right now, its having a field day with attempts to embrace Chat-Oriented Programming (“CHOP”)1.
See CHOP is the primary mode guiding what Software Composers and AI-first builders do.
But many dyed in the wool developers try and many fail.
Why?
For some, they proclaim it dumbs them down and they quit all together. And for others, well, the survey says it doesn’t actually increase those “key objective metrics”. You know things like cycle time, bugs detected, etc.
On the other hand very experienced practitioners like Nicholas Carlini have written about their positive experiences and this week David Crawshaw explained how he is trudging forward:
Chat-driven programming. This is the hardest of the three. This is where I get the most value of LLMs, but also the one that bothers me the most. It involves learning a lot and adjusting how you program, and on principle I don’t like that. It requires at least as much messing about to get value out of LLM chat as it does to learn to use a slide rule, with the added annoyance that it is a non-deterministic service that is regularly changing its behavior and user interface.
Last week I recounted my September Moment. Truth be told, my re-awakening was because of CHOP not in spite of it.
But it’s not because CHOP is easy. Not in the slightest.
There is another new 70% problem coined from a Peter Yang tweet. Addy Osmani extrapolates it further as the “Two Steps Back Pattern”:
What typically happens next follows a predictable pattern:
You try to fix a small bug
The AI suggests a change that seems reasonable
This fix breaks something else
You ask AI to fix the new issue
This creates two more problems
Rinse and repeat
I’ve experienced this and other frustrating patterns (e.g. deadlooping) more times than I can count. They’re pervasive and have consumed my thoughts.
Despite that friction, I’ve gathered a few heuristics over time—tricks to climb out of the quicksand before sinking.
Most importantly, however, I’ve tackled the psychological barriers that stand between frustration and fluency. So can you.
The Tale of Two Developers
Inside each of us, there really are two developers:
The Traditional Developer Self — Skilled, analytical, proud of every handcrafted line, and skeptical—if not downright hostile—towards AI-generated solutions.
The AI-Augmented Self — Intuitive, open to exploring possibilities, unafraid to throw ideas into the mix and refine them on the fly.
The tension between them is the Inner Game of CHOP.
What is it you want? To keep on breathing? What about feeling? desiring? growing? ceasing to grow? using your voice? thinking? Which of them seems worth having? — XII. 31
My First Rally
I remember my first real breakthrough with CHOP. I was stuck on a particularly nasty bug trying to implement Clerk authentication for a project I was working on in early September. A few hours in and my Traditional Developer Self was running out of steam.
"Just try it," my second self said, nudging towards the AI chat. "What's the worst that could happen?"
So I did. But instead of just pasting in the error message, I tried something different. I approached it like a conversation with a senior developer:
"Let's think about this authentication flow step by step. Here's what we're seeing..."
Claude then asked me questions I hadn't considered. It proposed solutions, yes, but more importantly, it helped me think through the problem in new ways and consult documentation and other examples I wouldn’t have thought to. In so doing it made me realize the power of CHOP to expand and amplify skills much more than I had previously given it credit for.
Finding that new Rhythm
In tennis, players use a simple "bounce-hit" drill to find their rhythm. In CHOP, I’ve developed a similar pattern:
Prompt (Bounce) → Review (Hit) → Refine → Repeat
And just like in tennis, the magic happens when you stop overthinking it. When you quiet that analytical voice that wants to control every aspect and instead trust in the flow of the conversation.
Every developer transitioning to CHOP faces certain tensions:
Control vs. Collaboration
Perfectionism vs. Pragmatism
Writing vs. Reviewing
Identity vs. Evolution
You can’t resolve them — you must dance. To acknowledge both sides of ourselves – the craftsperson who loves writing code and the problem-solver who's willing to experiment ceaselessly with new approaches.
Here’s how you ease into CHOP if you’re from a traditional background:
Start Small. Pick tasks that don’t threaten your identity: documentation, test cases, maybe a quick utility function. Let trust grow.
Practice Present-Moment Awareness. Focus on the problem itself, not on the “right” way to solve it. When you see AI-generated code, pause your knee-jerk criticism and simply observe.
Embrace the Conversation. CHOP isn’t one-sided. Don’t just ask for solutions—dialogue with the AI. Kick the tires, challenge its assumptions, explore alternatives.
Redefine Success. Ditch old metrics. Track problems solved, not just units of output or hours in front of the keyboard. Recognize that CHOP’s collaborative style is a different animal.
Notice the Tells. When your Traditional Developer Self barks “Real developers code everything from scratch!” or “I’m losing my edge!” remind yourself that these are just thoughts, not commands.
There’s a state you can reach in CHOP that’s unlike the flow states described in conventional programming. It’s more akin to an engaging tennis volley—both sides trading shots, building on each other’s momentum.
You’ll know you’re there when:
Prompts flow naturally. You anticipate the AI’s response and steer it intentionally.
Code review becomes second nature. You learn which diffs need careful study and which you can trust.
Solutions are born of dialogue. Problems that emerge get discussed, teased apart, and ultimately resolved—right there in the chat.
So no, CHOP doesn’t erode your expertise. It transforms it. All those invaluable skills—pattern recognition, architecture design, troubleshooting—shine brighter when you can build alongside AI
For the Brave Who Begin
Trust the Process. It will feel unnatural at first, and it may for a while yet.
Keep Tasks Contained. Don’t throw your biggest production app at the AI on day one.
Develop Prompt Mastery Slowly. Good prompting is an art.
Sharpen Your Fundamentals. You’ll still want to practice your pure-coding muscles.
Stay High-Level. Let CHOP handle the grunt work while you orchestrate the big picture.
Remember: your experience matters, your instinct matters, and your creativity matters. You’re not becoming less.
Welcome to the inner game of CHOP.
The court is open.
Prompt (Bounce) → Review (Hit) → Refine → Repeat
A term coined by Steve Yegge