Use Cases

1. Take screenshots of presentation slides with Cmd/Ctrl + H
2. Ask clarifying questions about concepts
3. Get instant explanations without interrupting the lecturer
4. Request examples or analogies for complex topics

Screenshot: Slide about neural network backpropagation
Question: "Explain how the chain rule applies here"
Result: Step-by-step breakdown with mathematical notation

1. Screenshot exam questions
2. Get structured problem-solving approaches
3. Verify formulas and methods
4. Check your work for logical errors

• Problem statement analysis
• Relevant context and background
• Multiple solution approaches
• Step-by-step reasoning

1. Screenshot text in foreign language
2. Request translation and explanation
3. Ask for grammar breakdowns
4. Get cultural context for idioms

• Gemini: Excellent multilingual support
• Ollama models like llama3.2: Good for common languages

Screenshot: Japanese technical documentation
Prompt: "Translate this and explain the technical terms"
Result: English translation + technical context

“If it is an APTITUDE/REASONING question (math, logical reasoning, puzzles, quantitative): Provide the correct answer with a clear step-by-step solution. Show the formula or method used.”

1. Screenshot the problem from textbook or assignment
2. Cluely automatically detects it’s a math problem
3. Provides:
   • Formula identification
   • Step-by-step solution
   • Alternative methods
   • Verification of answer

• Block equations: $x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}$
• Inline math: $E=mc^2$
• All formulas rendered beautifully with KaTeX

• Calculus and advanced mathematics
• Physics problems
• Chemistry equations
• Statistics and probability
• Logic puzzles

1. Keep Cluely window visible in corner of screen
2. Screenshot client’s concern in chat or presentation
3. Get instant talking points and objection handlers
4. Respond confidently without breaking conversation flow

• Problem restatement (ensures understanding)
• Relevant context (market data, competitor info)
• Multiple response strategies
• Reasoning behind each approach

Screenshot: "Your price is 30% higher than competitor X"
Cluely suggests:
1. Value-based response highlighting ROI
2. Feature differentiation talking points
3. Case study reference for similar client

“If it is a CODING/PROGRAMMING question: Provide TWO Java solutions - a BRUTE FORCE approach and an OPTIMIZED approach. Include Time and Space complexity as comments. Check test cases and constraints carefully.”

1. Screenshot the coding problem statement
2. Get immediate problem analysis
3. Review multiple solution approaches
4. Understand time/space complexity
5. Debug issues with additional screenshots

// From LLMHelper.ts:450-476
debugSolutionWithImages(problemInfo, currentCode, debugImagePaths)

• Brute force solution (simple, working)
• Optimized solution (interview-ready)
• Complexity analysis
• Edge case considerations
• Minimal code changes for bug fixes

1. Run Cluely on second monitor
2. Keep it translucent and always-on-top
3. Screenshot questions or data points
4. Get instant verification and additional context

• Verify statistics before citing
• Get additional examples to illustrate points
• Answer unexpected technical questions
• Provide quick competitor comparisons

USE_OLLAMA=true

1. Record meeting audio (with permission)
2. Upload audio file to Cluely
3. Get automatic analysis and summary

public async analyzeAudioFile(audioPath: string) {
  // Describes audio clip in concise answer
  // Suggests several possible actions based on audio
}

• Concise audio description
• Key points and themes
• Suggested follow-up actions
• Action items extraction

1. Screenshot the error message or stack trace
2. Get instant diagnosis and solutions
3. Understand root cause
4. Apply fix

• Python stack traces
• JavaScript console errors
• Compiler errors (Java, C++, Rust)
• Database errors
• API error responses

• Error explanation in plain English
• Root cause analysis
• Multiple solution approaches
• Prevention tips for future

debugSolutionWithImages(problemInfo, currentCode, debugImages)

• Minimal code changes to fix bug
• Respects debug constraints (e.g., “max 5 characters modified”)
• Shows exactly which lines changed

1. Screenshot complex code sections
2. Ask for explanation
3. Request optimization suggestions
4. Understand design patterns used

• Explains what code does
• Identifies design patterns
• Suggests optimizations
• Points out potential bugs
• Explains time/space complexity

Screenshot: Complex recursive function
Question: "Explain this and suggest optimization"
Result: 
  - Plain English explanation
  - Recursive call tree diagram (text-based)
  - Iterative alternative with better performance
  - Complexity analysis (O(2^n) → O(n))

1. Screenshot API documentation
2. Ask for usage examples
3. Get code snippets
4. Understand parameters and return values

• API usage examples
• Parameter explanations
• Common pitfalls to avoid
• Best practices
• Error handling patterns

• REST API documentation
• SDK documentation
• Library references
• Command-line tool help pages

1. Screenshot your requirements or whiteboard
2. Get architectural suggestions
3. Compare different approaches
4. Understand trade-offs

• Database schema suggestions
• Microservices vs monolith guidance
• Caching strategies
• Scalability considerations
• Security best practices

Screenshot: Whiteboard sketch of system architecture
Question: "Review this design for a real-time chat app"
Result:
  - Analysis of current design
  - Scalability bottlenecks identified
  - WebSocket vs polling recommendation
  - Database choice guidance (SQL vs NoSQL)
  - Suggested improvements

“If it is a MULTIPLE CHOICE question (MCQ): Identify the correct option and explain why it is correct and why other options are wrong.”

1. Screenshot practice exam questions
2. Get detailed answer explanations
3. Understand why wrong answers are incorrect
4. Learn underlying concepts

• AWS Solutions Architect certification
• Azure Administrator exam
• CompTIA certifications
• Coding interview prep (LeetCode, HackerRank)
• Database certifications

• Debug yesterday’s failing tests (screenshot stack traces)
• Review pull request code (screenshot complex sections)
• Understand new library (screenshot docs)

• Architecture meeting (screenshot whiteboard designs)
• Code review suggestions (screenshot proposed changes)
• API integration (screenshot error responses)

• LeetCode practice (screenshot problems, get solutions)
• Study system design (screenshot diagrams)
• Side project debugging (screenshot console errors)

• Review lecture slides (screenshot + ask for explanations)
• Practice problems (screenshot textbook questions)
• Understand formulas (screenshot equations, get derivations)

• Screenshot questions
• Get structured problem-solving approaches
• Verify final answers
• Check time/space complexity

• Review mistakes (screenshot incorrect solutions)
• Understand why answers were wrong
• Learn correct approach for future

• Research competitor products (screenshot comparisons)
• Prepare objection handlers (screenshot common concerns)
• Review product features (screenshot release notes)

• Handle unexpected questions (screenshot client messages)
• Get instant talking points
• Verify pricing or technical details
• Provide additional examples

• Draft follow-up email (screenshot call notes)
• Create proposal outline (screenshot requirements)
• Schedule next steps (screenshot action items)