Skip to content
BSWEN
Blog

How to Use Advanced Claude Code Prompts from the Founding Team

Cowrie
Cowrie
Dev @ Bswen

Problem

When I use Claude Code, I often accept the first answer without verification. Sometimes the solution works, but sometimes I miss edge cases or better alternatives.

The problem is: generic prompts produce generic results. I say “implement this feature” and Claude gives me working code—but is it the best approach? Did I consider all edge cases?

Environment

  • Claude Code CLI
  • Any project type

What happened?

I noticed a pattern in my workflow:

  1. I ask Claude to implement something
  2. Claude gives me code
  3. I accept it without questioning
  4. Later, I find bugs or realize there was a better way

This cycle wastes time. I wanted to find better prompting techniques.

So I looked at what the Claude Code founding team recommends. They use specific prompt patterns that force deeper thinking and verification.

How to solve it?

I found four techniques that changed how I use Claude Code:

Technique #1: Role Reversal

Instead of Claude testing me, I make Claude test my understanding.

Role reversal prompt
"Ask me questions about these changes before submitting the PR.
Don't proceed until I pass your test."

When I use this prompt, Claude becomes the interviewer. It asks about edge cases I missed, error handling I forgot, and test scenarios I should add.

Example: I asked Claude to refactor a function. Then I said: “Ask me questions about these changes.” Claude asked: “What happens if the input is null? Have you tested the edge case where the array is empty?”

I caught two bugs before they reached production.

Technique #2: Self-Verification

Don’t trust Claude’s claim that something works. Make Claude prove it.

Self-verification prompt
"Prove this solution works. Compare the diff between
main and feature branches."

This forces Claude to write verification logic, not just claim “this should work.”

Example: I asked Claude to fix a race condition. Claude said “this should fix it.” I replied: “Prove it works by showing the before and after execution flow.” Claude then wrote out the exact scenario where the bug occurred and how the fix prevents it.

Technique #3: Reconsideration

The first solution is rarely the best one. Ask Claude to推翻 (overturn) its own approach.

Reconsideration prompt
"Based on what you now know,推翻 your previous approach
and propose a more elegant implementation."

I found that the second solution is often significantly better.

Example: Claude suggested a nested-if approach for a validation function. I asked for reconsideration. Claude then proposed a guard-clause pattern that was cleaner and easier to test.

Technique #4: Spec-First

Vague requirements produce vague code—for both humans and AI.

Spec-first prompt
"Before implementing, write a detailed specification for this feature.
Include: inputs, outputs, edge cases, error handling, and test scenarios."

This technique has saved me from incomplete implementations more times than I can count.

Example: I said “add pagination to the user list.” Claude started writing code. I stopped it: “Write a spec first with all edge cases.” The spec revealed we needed: cursor-based pagination, rate limiting, and empty-state handling. The final implementation was complete on the first try.

Bonus: Learning Mode

While working, I can enable explanatory output to learn as I code:

Enable learning mode
/config
# Set output style to "Explanatory" or "Learning"

Now Claude explains changes while making them, helping me understand the “why” behind each decision.

Bonus: ASCII Diagrams

For architecture discussions, I ask Claude to draw ASCII diagrams:

ASCII diagram prompt
"Draw an ASCII flowchart explaining the call chain of this module"

This gives me instant visualization in the terminal—no external tools needed.

ASCII diagram example
User Request → Router → Controller → Service → Repository
                              ↓
                         Validation
                              ↓
                         Response

The reason

These techniques work because they change the dynamics of human-AI collaboration:

  • Role reversal shifts Claude from “answer generator” to “critical reviewer”
  • Self-verification adds a proof step before acceptance
  • Reconsideration explores the solution space more thoroughly
  • Spec-first ensures requirements are complete before coding

Generic prompts skip these critical thinking steps. Advanced prompts force them into the workflow.

Summary

In this post, I showed four advanced prompt patterns for Claude Code: role reversal, self-verification, reconsideration, and spec-first approach. The key point is that generic prompts produce generic results—use these patterns to force deeper thinking and verification.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: