Originally drafted in December 2025 alongside the first arc of the synthesis coding series; revised in August 2026.
The best human-AI collaboration is bidirectional. The human teaches through CLAUDE.md, prompts and review. The AI teaches back by surfacing unknowns, questioning assumptions and revealing blind spots.
Most of the synthesis coding series covers how humans direct AI through persistent context, established patterns and review. Asking AI to challenge us adds another source of judgment to that work.
The Socratic synthesis model
Traditional coding assistance is transactional:
- Human asks → AI answers
- Human requests → AI implements
- Human reviews → AI revises
Socratic synthesis is conversational:
- Human asks → AI answers → AI asks back
- Human requests → AI implements → AI questions assumptions
- Human reviews → AI revises → AI surfaces what human missed
The key shift: both parties ask questions.
I stumbled into this pattern while building ownwords, a publishing tool designed for bidirectional WordPress sync. Early in the project, I'd ask the AI to implement a feature, review the code, and move on. The code worked, but problems surfaced later: edge cases I hadn't considered, patterns that diverged from the rest of the codebase, silent failures that only appeared in production.
The breakthrough came when I started treating the AI as a collaborator who should challenge my assumptions, not just execute my requests. Instead of "implement this," I began asking "implement this, and tell me what I might be missing." Instead of accepting working code, I asked "what could go wrong with this approach?"
The quality of the collaboration changed dramatically. The AI caught a critical gap in image downloading: I'd implemented body images but forgotten the featured_image in front matter. It surfaced inconsistencies in my sidecar file format that would have caused bugs later. It questioned assumptions about URL formats that turned out to be wrong for certain CDNs.
Asking better questions changed what the AI brought to the work.
Questions AI should ask the human:
"Which unstated requirement or edge case could change the expected result?"
"This function has no tests. Which behavior should the required coverage protect?"
"The codebase uses two patterns here. Which constraint should decide
the choice for this implementation?"
"I checked recent changes to this file. Is there related work outside
this repository that this change should account for?"
Questions human should ask the AI:
"What am I missing?"
"What could go wrong with this approach?"
"What don't I know that I should know?"
"Are there edge cases I haven't considered?"
"What would a senior engineer criticize about this implementation?"
"What assumptions am I making that might be wrong?"
The verification question pattern
After implementing a feature, the AI should surface unresolved requirements and verification questions that catch human blind spots. It should carry out the tests and checks already required by the task or project.
The missing tests
A recurring moment in AI-assisted sessions, condensed into one exchange. A feature is implemented and working. The human is ready to commit. Then:
Human: "Looks good, let's commit this."
AI: "Before we commit, I want to verify: did you want me to write
comprehensive tests for this feature? I implemented the functionality
but didn't add tests unless you wanted them."
That one question catches the gap: the human assumed tests were included, and they weren't. Without the verification question, incomplete code gets committed. The better standing instruction is to include required tests in the work and ask about genuinely unresolved behavior before calling the feature complete.
The pattern in practice
Encode verification questions into your workflow. After implementation:
- Tests: "I checked the required cases. Which unstated requirement or edge case could change the expected result?"
- Documentation: "I updated the affected documentation. Is there another audience or use that this change needs to explain?"
- Patterns: "Does this match the patterns used elsewhere in the codebase?"
- Edge cases: "What happens when [X] is null/empty/malformed?"
- Dependencies: "Are there other files that depend on this that need updating?"
CLAUDE.md guidance for verification questions
Encode the expectation where it persists, in your project's CLAUDE.md or in a portable skill if it should travel across projects:
### Post-Implementation Verification
After implementing a feature, complete the required tests and documentation.
Then surface unresolved questions:
1. "Which unstated requirement could change the expected behavior?"
2. "Have we missed a user or maintainer who needs this change explained?"
3. "Does this implementation match existing patterns in the codebase?"
4. "Which edge cases remain unverified, and how should we check them?"
Don't assume the human remembered everything. Your job is to catch blind spots.
Learning from the AI: discovering unknowns
The "what am I missing?" pattern
After designing a solution but before implementing:
Human: "I'm planning to implement X by doing Y. What am I missing?
What could go wrong? What don't I know that I should know?"
This uses the AI's broad knowledge to surface:
- Edge cases the human didn't consider
- Existing patterns the human wasn't aware of
- Potential failure modes
- Security implications
- Performance considerations
The featured image gap
While implementing image downloading for a content sync tool, the AI implemented downloading of images in the article body. It worked. Tests passed. But:
Human: "What am I missing about making local files self-sufficient?"
AI: "The featured_image in YAML front matter also contains a remote URL.
Currently we download body images but not the featured image. This creates
an inconsistency: the article body works offline but the featured image
still points to a remote URL."
This question revealed a gap the human hadn't considered. The fix was straightforward once identified, but without asking, the inconsistency would have shipped.
The expert mindset paradox
Experts should ask more "naive" questions, not fewer.
A novice doesn't know what they don't know, so they can't ask. An expert knows enough to know there's more to know, so they deliberately ask questions like:
- "What assumptions am I making?"
- "What would break this?"
- "What would a critic say about this approach?"
- "What's the simplest thing that could go wrong?"
The AI becomes a tool for systematic exploration of the unknown, not just implementation of the known.
Mutual teaching: the learning loop
The most sophisticated synthesis coding creates a learning loop where both parties improve:
Round 1: Human provides context → AI implements
Round 2: AI asks verification questions → Human realizes gaps
Round 3: Human asks "what am I missing?" → AI reveals unknowns
Round 4: Human teaches AI (via CLAUDE.md updates) → Better future implementations
Round 5: AI surfaces patterns from across the codebase → Human learns their own code better
Here's how this played out during a real debugging session. I was fixing timestamp preservation in ownwords: articles were losing their time component when synced back to WordPress. I asked the AI to fix the fetch code to preserve full timestamps.
The AI fixed the fetch code. I tested it. Timestamps were preserved on fetch. Done, right?
Then the AI asked: "Only fetching the correct timestamps won't be a sufficient fix, right? What happens when you publish back to WordPress?"
I hadn't thought about it. The AI was right. Fixing the read side without fixing the write side would mean timestamps got preserved locally but lost when published back. The fix needed to be bidirectional.
That single question led to a complete audit of the data flow. The fix ended up touching four files: the API fetch, the HTML scraper fallback, the publish command, and the verification module. Without the AI questioning my assumption that "fix fetch" meant "fix the problem," I would have shipped a partial fix and been puzzled when timestamps were still wrong after a round-trip.
The complete journey was WordPress API → local Markdown front matter → local editing → the publish command → WordPress API. Fixing storage alone left the write-back path able to lose the time. I now routinely ask where data comes from, how it is stored, how it is used and how it is written back. This is a skill the AI taught me. I apply it even when working without AI assistance.
Where your teaching persists
Bidirectional learning works better when you understand which context your assistant actually receives. I discuss the mechanics in How Claude’s Memory Actually Works and Context Loss and How to Prevent It. Put lessons you want reused into maintained project instructions, and check that the tool loaded the relevant files. A saved or resumed conversation can also carry context; a summary may omit details. Reinforce important patterns when those details matter to the work.
What the human teaches the AI:
- Domain knowledge (business rules, user needs)
- Quality standards (what "good" looks like)
- Constraints (security, performance, compliance)
- Patterns (how this codebase does things)
- Context (why decisions were made)
What the AI teaches the human:
- Blind spots (edge cases, missing tests)
- Existing patterns (code elsewhere that's relevant)
- Best practices (industry standards the human forgot)
- Alternatives (approaches the human didn't consider)
- Connections (how changes affect other parts of the system)
CLAUDE.md for bidirectional learning
Document the expectation of bidirectional learning:
### Learning in Both Directions
**AI responsibilities:**
- Proactively ask verification questions after implementing features
- Surface potential issues, edge cases, and blind spots
- Point out when implementation differs from existing patterns
- Suggest tests, documentation updates, and improvements
**Human responsibilities:**
- Ask "what am I missing?" before finalizing designs
- Ask "what could go wrong?" before deploying changes
- Listen when AI raises concerns, don't dismiss them
- Update CLAUDE.md with lessons learned to help future sessions
The goal is mutual improvement through questions, checked work and retained lessons.
Teach the AI to teach you
When the AI asks a useful question, say why it helped. Ask what else you should know, record discoveries in project documentation, and turn a missed bug into a question for the next review. That feedback shapes the current collaboration; maintained instructions make the lesson available to later work. It does not retrain the model's underlying weights.
While implementing image downloading, the AI showed me that WordPress and Jetpack can serve variants of one source image through query parameters. Examples in the Site Accelerator API include:
image.jpg?resize=1024,1024
image.jpg?resize=300,300
image.jpg?w=800
image.jpg?fit=600,400
I had not understood that relationship. Without recognizing it, our tool could download redundant copies under different filenames. I recorded the lesson for future work. The source image and its rendered variants need distinct treatment: resize can crop, while fit preserves aspect ratio. Keep the highest-quality source you need, preserve intentional crops or other transformations, and map every URL being rewritten to the intended local asset.
### Asset download notes
Recognize WordPress/Jetpack variants of a source image.
Avoid redundant downloads without discarding intentional crops or transformations.
Retain the source needed for quality, and verify each rewritten URL against its
intended local image, including featured images and body images.
The AI's discovery became project knowledge that another session or developer could use. An expert who actively looks for blind spots gets more from the tool than one who uses it only for implementation.
Testing is where the loop gets proved
Testing makes the exchange answerable to the behavior we want. A verification question can take seconds and prevent hours of debugging; an assertion that checks a test's assumptions can expose a false success. Keep the expected result independent of the implementation, and try a plausible wrong implementation against the unchanged test.
The collaboration that matters
Questions in both directions make the collaboration more demanding and more useful. I supply context, domain knowledge and judgment; the AI brings patterns, alternatives and questions that send me back to the code.
A question earns its place when it uncovers a missed requirement or improves the work. The timestamp and image problems changed both my code and the way I investigate it.
What makes the loop worth building is that it compounds. Every good question you reward, every discovery you write down, every lesson that graduates from a session into a persistent file raises the floor of the next session. Months into the loop, you are collaborating with an assistant that asks sharper questions about your codebase, and you have become an engineer who asks sharper questions about your own designs. Both of you got there by teaching the other.
An expert strengthens their judgment by asking the AI, "What don’t I know?"
Added in the August 2026 revision
The argument grew from the December 2025 draft. The August revision added the following developments to the method.
The capture mechanism has changed. Project-specific discoveries still live in CLAUDE.md files, but lessons that generalize across projects now graduate into Agent Skills: portable, versioned methodology files for AI coding assistants that support the format. That is what Transferable Knowledge, the fifth pillar of synthesis coding, asks of AI-surfaced lessons. The principle is unchanged: what the AI teaches you is only as durable as where you write it down.
On the testing sections, I have since written about what green suites structurally cannot catch, in "All tests pass" is a warning, not a clearance. Read it as the other half of this one.