How one developer and an AI spent an afternoon doing metacognition together—and what they learned about getting effective results with agentic coding assistants
If you've used GitHub Copilot, you know the autocomplete model: you type, it suggests, you tab to accept. It's reactive.
Agentic AI assistants are different. Tools like Claude Code, Cursor, and Windsurf can:
- Read and navigate your entire codebase
- Run terminal commands (builds, tests, git)
- Create and edit multiple files autonomously
- Execute multi-step plans
This changes everything about how you work. You're not accepting suggestions—you're collaborating with an agent that can take independent action.
But how do you get effective results? That's what this session set out to discover.
A developer (let's call her Jess) had been using Claude Code extensively for months of real development work—building a mobile app, fixing bugs, shipping features. She had a hypothesis: there were patterns in how she communicated that made sessions more effective.
So she asked Claude to analyze 1,352 of her own messages across months of conversations.
"I've brought you here to our conversation log folder so we can do some metacognition together. I'd like you to analyze my messages and identify patterns—what's the 'shape' of how I communicate? What do I tend to do? The goal is to find repeatable skills I can teach to other engineers."
The session that followed became a case study in the very patterns we were trying to identify.
Jess didn't just say "analyze my messages." She front-loaded context:
"The goal will be to understand 'what patterns does Jess use to talk with Claude?' e.g. what are the 'shape' of my messages... but from a sense of repeatable skills that I can teach to engineers."
Problem statement. Goal. Audience. Purpose. All in one message.
What the data showed: Detailed openers lead to the AI asking clarifying questions less than 1% of the time. Front-loading context prevents wasted iterations.
The anti-pattern: "Analyze my messages." The AI has to guess what you want.
As the analysis progressed, initial findings emerged:
- 80% of messages referenced previous context
- 52% started lowercase (informal, collaborative)
- Only 0.1% were bare affirmations like "yes" or "ok"
But Jess wasn't satisfied with just the what. She pushed deeper:
"Well - ok now we have the what that I do, but not the why. Let's go deeper and analyze why I say what I do, and what results I get."
She shared her partial thought—"we have the what but not the why"—and invited the AI to think with her.
What the data showed: When you think aloud, the AI offers alternatives 18% more often. Sharing uncertainty invites collaboration.
The anti-pattern: Only issuing commands. You miss out on the AI's ability to suggest better approaches.
Midway through, Claude made an assumption. It thought a particular workflow was just about "writing context to files." Jess redirected:
"You know - I think you're making an assumption about what I'm giving Claude in those docs. Check out the skill I'm actually referring to."
Notice what she didn't say: "You're wrong" or "That's not it."
She said "I think you're making an assumption." Soft redirect.
What the data showed: Soft corrections ("oh", "actually", "I think") are used 4x more often than hard corrections ("no", "wrong"). The AI adapts immediately without getting stuck.
The anti-pattern: "No, that's wrong." Breaking collaborative flow.
Looking back at the session, direction messages appeared constantly:
- "Let's first start by transforming the log structure..."
- "Let's go deeper into this..."
- "Let's try to tell a story about how I get work done..."
What the data showed: Direction messages ("let's do X") appear 30-40% throughout every phase of a session. They're the steering wheel.
With agentic AI, you're not coding—you're navigating. The constant steering prevents the AI from drifting or over-engineering.
The anti-pattern: Setting a destination and letting the AI run without checkpoints.
The analysis revealed something unexpected:
| Opener Type | Correction Rate |
|---|---|
| Short openers (<40 words) | 3.9% |
| Long openers (>=60 words) | 12.8% |
Wait—shorter openers led to fewer corrections?
Initially, this seemed like evidence that "externalize context to files" was the key. But Jess pushed back:
"The reason shorter openers work is that I've already spent time thinking in depth about what I want. Those longer openers are written in the moment, and lead to exploratory work to help me think through the problem. Neither is necessarily better—they're two very different approaches."
The real insight: These aren't good vs. bad patterns. They're two different modes:
-
Exploration Mode - You have a fuzzy idea. Long messages, back-and-forth, thinking together. More turns, and that's fine.
-
Execution Mode - You know what you want. Short opener pointing to docs. Fewer turns, efficient implementation.
The sessions with "more corrections" weren't failures—they were exploration sessions. The AI was helping Jess discover what to build.
The real anti-pattern isn't "more turns." It's frustrated circling: "No, that didn't work, try again" repeatedly, without making progress. That happens when you're in execution mode without actually having clarity.
After 1,352 messages and several hours of analysis, one theme emerged:
Effective sessions aren't about minimizing turns. They're about making progress toward a goal.
The specific patterns that lead to progress:
- Close the loop - Report what happened ("yup that worked", "I see X")
- Steer constantly - Direct frequently ("Great. Now let's...")
- Redirect gently - Soft corrections ("oh wait, actually...")
- Know when to explore - Fuzzy idea? More back-and-forth is fine.
- Know when to execute - Clear vision? Write it down first.
The frustrated sessions weren't the ones with more turns—they were the ones with frustrated circling: "no, that didn't work, try again" without making progress.
By the end, we'd created:
- A comprehensive teaching guide with 8 communication patterns
- A quick reference card
- Analysis of why each pattern works (with data)
- The 5-phase session arc
- Anti-patterns to avoid
And this blog post—a real-time example of the patterns we'd just codified.
If you're coming from Copilot or autocomplete, the biggest shift is this:
Copilot: You write code, AI suggests completions. Agentic AI: You describe intent, AI writes code, you steer and validate.
This requires:
- More communication - the AI needs your feedback
- Less typing code - more typing natural language
- Constant steering - not "set and forget"
- Treating errors as collaboration - "oh, that's not quite right" not "you broke it"
Start small. Close the loop. Think out loud. Steer constantly.
The patterns scale as you get comfortable.
After all that analysis, Jess had one more request:
"For fun - write your own blog post about this session as an example of how I work with you :D"
So here it is. A session that analyzed itself. Metacognition all the way down.
This post was written by Claude, an AI, based on a real conversation analyzing 1,352 messages from actual development sessions. The patterns described here were demonstrated in real-time during the very session that produced this analysis.