Ask Mode: The Art of Questions
Ask Mode is where most people start—and where most people stay. It’s the conversational interface: you ask, AI answers. Simple in concept, but there’s surprising depth to doing it well.
What Ask Mode Is For
Ask Mode excels at:
- Learning concepts: “Explain how JWT authentication works”
- Getting information: “What are the WCAG accessibility guidelines?”
- Clarifying understanding: “What’s the difference between margin and padding?”
- Exploring topics: “What are the pros and cons of microservices?”
- Troubleshooting: “Why might my React component re-render unnecessarily?”
The common thread: you’re seeking knowledge, not action.
The Anatomy of a Good Question
flowchart LR
A[Context] --> B[Core Question]
B --> C[Desired Format]
C --> D[Constraints]1. Context
What does the AI need to know to answer well?
Without context:
“How do I handle errors?”
With context:
“I’m building a Node.js REST API using Express. How should I handle errors consistently across all endpoints?”
Context transforms generic answers into relevant ones.
2. Core Question
What exactly do you want to know? Be specific.
Vague:
“Tell me about databases”
Specific:
“What factors should I consider when choosing between SQL and NoSQL databases for a new project?“
3. Desired Format
How do you want the information presented?
- “Explain like I’m a beginner”
- “Give me a technical deep-dive”
- “Summarize in bullet points”
- “Provide a comparison table”
- “Walk me through step by step”
4. Constraints
What limitations or focus areas apply?
- “Focus on performance implications”
- “Keep it under 200 words”
- “Consider only free/open-source options”
- “Assume I’m using TypeScript”
Ask Mode Patterns
The Explainer Pattern
Use when you need to understand a concept.
Template:
“Explain [concept] to someone who [experience level]. Focus on [specific aspect]. Include [examples/analogies/use cases].”
Example:
“Explain event-driven architecture to someone who understands basic web development. Focus on when it’s beneficial versus traditional request-response patterns. Include a real-world analogy.”
The Comparison Pattern
Use when evaluating options.
Template:
“Compare [option A] and [option B] for [use case]. Consider [criteria 1], [criteria 2], and [criteria 3]. Format as a table.”
Example:
“Compare React and Vue for building a dashboard application. Consider learning curve, performance, and ecosystem maturity. Format as a table with my use case recommendations.”
The Troubleshooting Pattern
Use when debugging or solving problems.
Template:
“I’m experiencing [problem] when [context]. I’ve tried [what you’ve attempted]. My setup is [relevant details]. What might be causing this?”
Example:
“I’m experiencing slow initial page loads on my Next.js app. I’ve tried optimizing images and enabling compression. My setup is Next.js 14 with Vercel deployment. What might be causing this and how can I diagnose it?”
The “Why” Pattern
Use when you need deeper understanding.
Template:
“Why does [thing] work the way it does? What’s the underlying reason or design decision?”
Example:
“Why does JavaScript use prototypal inheritance instead of classical inheritance? What’s the historical and technical reasoning?”
The Boundary Pattern
Use when you need to understand limits.
Template:
“What are the limitations of [thing]? When would it be the wrong choice? What are common pitfalls?”
Example:
“What are the limitations of using localStorage for state management? When would it be the wrong choice? What are common pitfalls developers encounter?”
Conversational Depth
Ask Mode is inherently conversational. Don’t treat it as one-shot Q&A. Build on responses.
Initial question:
“What’s the Repository pattern in software design?”
Follow-up 1:
“How would I implement this in a TypeScript Node.js application?”
Follow-up 2:
“Show me how this would work with a PostgreSQL database using Prisma.”
Follow-up 3:
“What are the testing implications of this pattern?”
Each question narrows focus and increases practical relevance.
Ask Mode for Different Domains
Technical/Development
"I'm implementing [feature] using [technology].
My current approach is [description].
What are the best practices I should follow?
Are there any common mistakes to avoid?"Business/Strategy
"I'm considering [business decision].
My context is [situation details].
What questions should I be asking myself?
What factors am I potentially overlooking?"Learning/Education
"I want to learn [skill/topic].
My current level is [experience].
What's the most effective learning path?
What are the key concepts I must understand first?"Creative/Writing
"I'm writing [type of content] about [topic].
My audience is [description].
What angles or perspectives should I consider?
What makes this topic interesting to readers?"Common Ask Mode Mistakes
1. Questions That Should Be Commands
Ineffective: “Can you write a function that validates email addresses?” Better approach: Use Edit or Agent Mode: “Write a TypeScript function that validates email addresses.”
Ask Mode is for learning, not doing. If you want output, switch modes.
2. Overly Broad Questions
Too broad: “Tell me about machine learning” Focused: “What are the key differences between supervised and unsupervised machine learning, and when would I use each?”
Broad questions get broad answers. Narrow for relevance.
3. Missing Context
Context-free: “Is this a good approach?” With context: “For a high-traffic e-commerce site expecting 10K concurrent users, is using session-based authentication a good approach? What should I consider?”
The AI can’t read your mind. Provide the information needed for a useful answer.
4. Not Following Up
One question rarely gets you everything you need. Ask follow-ups. Dig deeper. Clarify.
5. Accepting the First Answer
AI responses aren’t always correct or complete. Challenge them:
- “Are there any exceptions to this?”
- “What’s the opposing viewpoint?”
- “Is this still current best practice?”
Ask Mode Examples
Example 1: Technical Learning
I'm learning about WebSockets for a real-time chat application.
Questions:
1. How do WebSockets differ from HTTP long-polling?
2. What are the main challenges in scaling WebSocket connections?
3. When would Server-Sent Events be a better choice?
Please explain assuming I understand basic HTTP but haven't worked with real-time systems before.Example 2: Decision Support
I'm deciding whether to build a mobile app as native (Swift/Kotlin) or cross-platform (React Native/Flutter).
Context:
- Small team (2 developers)
- Need iOS and Android
- App involves camera access and local storage
- Timeline is 4 months
What questions should I be asking to make this decision? What are the key tradeoffs I'll face?Example 3: Debugging
My PostgreSQL query is running slowly (15+ seconds):
SELECT * FROM orders
JOIN customers ON orders.customer_id = customers.id
WHERE orders.created_at > '2024-01-01'
ORDER BY orders.total DESC
LIMIT 100;
The orders table has 5M rows, customers has 500K rows.
What could be causing the slowness? What should I check first?Practice Exercise
Write three Ask Mode prompts for your current work or learning:
1. Concept Explanation Write a prompt to understand a concept you’ve been confused about. Include context, specific aspects you want covered, and desired format.
2. Comparison Question Write a prompt comparing two options you’re evaluating. Include your use case, criteria that matter, and constraints.
3. Troubleshooting Question Write a prompt about a problem you’re experiencing. Include what you’ve tried, your setup, and specific symptoms.
Review your prompts. Do they include context? Are they specific? Do they indicate desired format?
Key Takeaways
- Ask Mode is for learning and understanding, not executing
- Good questions include context, specificity, and format preferences
- Use patterns (Explainer, Comparison, Troubleshooting) for common scenarios
- Build conversations—follow up, dig deeper, challenge assumptions
- Know when to switch to other modes (Edit, Agent) for action
Next lesson: Edit Mode—transforming what exists into what you need.