The two roles have names: the one typing is the driver and the one guiding is the navigator. To switch, Do you want to drive?; to think out loud, I'm going to try….
Easy phrases (128)
Do you want to drive or navigate?
When to use it: Deciding roles at the start of a pair programming session
I'll drive first, and we can switch in 20 minutes.
When to use it: Setting up a rotation schedule for pair programming roles
Can you share your screen?
When to use it: Asking your pair to share their screen for a remote session
Let me think out loud for a second.
When to use it: Pausing to verbalize your thought process to your pair
What do you think about this approach?
When to use it: Asking your pair for feedback on a proposed solution
Can you explain what this function does?
When to use it: Asking your pair to walk you through unfamiliar code
Let's write a test for this before we move on.
When to use it: Suggesting to add a test while pairing before proceeding
Good catch! I wouldn't have noticed that.
When to use it: Acknowledging when your pair spots a mistake or improvement
Can you zoom in? I can't read the code from here.
When to use it: Asking to increase font size during a remote or in-person pairing session
You're going too fast. Can you slow down a bit so I can follow along?
When to use it: Asking your pair to reduce their pace during collaborative coding
Can you walk me through this function before we start refactoring it?
When to use it: Asking your pair to explain existing code before making changes
Let's write the test first and then figure out the implementation together.
When to use it: Starting with TDD approach during a pair programming session
I'm lost — can you scroll back up to where we defined that variable?
When to use it: Asking your pair to navigate back to a previous section of code
Nice catch! I totally missed that edge case.
When to use it: Acknowledging when your pair spots a bug or oversight you missed
I have an idea but I'm not sure it'll work. Mind if I try it real quick?
When to use it: Proposing an experimental approach during pairing
Let's swap — you've been driving for a while and I want to try something.
When to use it: Requesting to switch roles during a pairing session
Before we write any code, let's sketch out the approach on a whiteboard.
When to use it: Planning before coding during a pair programming session
Let me share my VS Code session so we can both edit in real time.
When to use it: Setting up a Live Share session for remote pair programming
I learned a new keyboard shortcut — watch this, it'll save us a lot of time.
When to use it: Sharing productivity tips with your pair during coding
Can you zoom in a bit? The font is too small for me to read from here.
When to use it: Asking your pair to adjust display settings during remote pairing
Let me pull up the acceptance criteria so we don't miss anything.
When to use it: Referencing requirements during pairing to stay on track
We've been going for two hours. Let's take a break and come back with fresh eyes.
When to use it: Recognizing fatigue and suggesting a break during a long pairing session
Your approach is interesting. I've never used that pattern before — can you explain how it works?
When to use it: Learning from your pair's different technique or pattern
Let's commit what we have so far and continue in a new branch.
When to use it: Saving progress by committing incrementally during pairing
I keep getting a type mismatch here. Can you take over and see if you spot the issue?
When to use it: Handing the keyboard over when you're stuck on a specific error
Let's review the git diff together before pushing to make sure everything looks right.
When to use it: Doing a final review of changes before submitting code
I'm going to mute my mic for a minute while I read through this code block.
When to use it: Taking a moment to silently read code during remote pairing
I've never worked with this framework before — this is a great learning opportunity for me.
When to use it: Acknowledging a knowledge gap and being open to learning during pairing
I'm going to type while you dictate — tell me what to write next.
When to use it: Adopting a dictation style of pair programming
Let's use the Pomodoro technique — 25 minutes of focused pairing, then a five-minute break.
When to use it: Structuring a pairing session with timed intervals
Can you open the terminal in a split view? I want to see the logs while we make changes.
When to use it: Optimizing the screen layout for simultaneous coding and monitoring
The connection is lagging — let me restart the Live Share session.
When to use it: Troubleshooting remote pairing tools when they're not performing well
Let's create a TODO comment here and come back to it — this is a separate concern.
When to use it: Deferring tangential work to stay focused on the current task
The build is taking too long. Let's review the PR description while we wait.
When to use it: Making productive use of wait time during pairing
I just realized this component already exists in our shared library. We don't need to rewrite it.
When to use it: Discovering existing reusable code that avoids duplication
Do you have a preference for how we name this function? I'm torn between two options.
When to use it: Collaborating on naming decisions during development
Let's annotate the code with comments for now and clean them up later.
When to use it: Using temporary comments to track thoughts during complex implementation
I like how you structured that. Can you explain the thought process so I can apply it elsewhere?
When to use it: Actively learning from your pair's problem-solving approach
I just noticed the CI is failing on our branch. Let's check the logs before we continue.
When to use it: Responding to CI failures during a pairing session
Let's pair on the code review — we can go through the diff together and leave comments.
When to use it: Doing code reviews collaboratively as a form of pairing
I'm going to rename this variable to something more descriptive — currentUserPermissions instead of just perms.
When to use it: Improving code readability during collaborative coding
That was a tough one. Nice job figuring it out together — I don't think I could've solved it alone.
When to use it: Celebrating collaborative problem solving after a difficult challenge
Let's do a quick code walkthrough of the existing module before we start making changes.
When to use it: Understanding legacy code before modifying it during pairing
Let's look at how other teams solved this by checking the internal codebase.
When to use it: Researching existing solutions within the organization during pairing
I'm going to copy the curl command from Postman so we can test the endpoint from the terminal.
When to use it: Using API tools during collaborative testing
You handle the frontend changes and I'll update the backend to match.
When to use it: Splitting full-stack work across the pair for parallel development
I have a feeling this is a caching issue. Let's clear the cache and try again.
When to use it: Troubleshooting intermittent issues during collaborative debugging
Let's not fix the formatting manually — just run the code formatter and let it handle everything.
When to use it: Using automated tools instead of manual formatting during pairing
Great pairing session today. I feel like I learned a lot about how you approach architecture decisions.
When to use it: Giving positive feedback after a productive pairing session
Can you check Stack Overflow for that error while I try a different approach?
When to use it: Dividing research and coding work during troubleshooting
Thanks for pairing with me today — next time let's tackle the authentication flow together.
When to use it: Wrapping up a session and planning the next pairing topic
Can you walk me through what you're thinking here?
When to use it: Asking for explanation while pairing
Let me take over the keyboard for a bit.
When to use it: Switching driver role
That's a clever solution, I wouldn't have thought of that.
When to use it: Giving positive feedback
Let's break this problem down into smaller pieces.
When to use it: Suggesting approach
Should we commit what we have so far before continuing?
When to use it: Suggesting incremental progress
Can you zoom in on that part of the code? I can't read it clearly.
When to use it: Asking for visibility
Let's add a comment here to explain why we're doing this.
When to use it: Suggesting documentation
I think there's a simpler way to do this, let me show you.
When to use it: Suggesting alternative
Wait, I think we introduced a bug. Let me scroll back.
When to use it: Catching a mistake
Good catch! I completely missed that null check.
When to use it: Acknowledging partner's contribution
Let me run the tests to make sure we didn't break anything.
When to use it: Verifying changes
Let's use the debugger to step through this code.
When to use it: Suggesting debugging approach
Can you explain the business logic behind this feature?
When to use it: Asking for context
Let's look at the documentation for this library before using it.
When to use it: Suggesting research
Your idea is better than mine, let's go with your approach.
When to use it: Deferring to partner
I'm getting a compile error on this line, can you spot the issue?
When to use it: Asking for help with error
Let's take a five-minute break, I need to clear my head.
When to use it: Suggesting a break
I learned something new from you today, thanks for sharing.
When to use it: Expressing gratitude for learning
Can you share your screen? The audio is fine but I can't see the code.
When to use it: Technical setup
Let's try the other approach and see if the tests pass.
When to use it: Suggesting experimentation
I noticed a typo in the variable name, should be camelCase.
When to use it: Catching naming error
Nice, the test is green. Let's move on to the next scenario.
When to use it: Celebrating progress
I don't think we need this import, it's unused.
When to use it: Catching unnecessary code
Let me draw a diagram to explain what I'm thinking.
When to use it: Visual communication
Let's look at how the existing code handles this case.
When to use it: Suggesting reference
This is a good learning opportunity, take your time with it.
When to use it: Encouraging learning
Let's timebox this to 30 minutes and reassess if we're stuck.
When to use it: Managing time
I think the naming could be more descriptive, what about calling it processPayment?
When to use it: Suggesting naming improvement
Can you explain this algorithm to me? I want to make sure I understand it.
When to use it: Asking for knowledge transfer
Let's use print statements to debug this quickly.
When to use it: Suggesting quick debugging
That's a great refactoring, the code reads much better now.
When to use it: Giving positive feedback
Should we add a guard clause at the top of this function?
When to use it: Suggesting defensive coding
Let's commit this working version and then optimize later.
When to use it: Prioritizing progress
Interesting approach, I've never seen it done that way before.
When to use it: Acknowledging novelty
The linter is complaining about the line length, can we split this?
When to use it: Following code standards
I'll type the test, you tell me what assertions we need.
When to use it: Dividing pairing tasks
We should probably create a feature branch for this.
When to use it: Suggesting git workflow
Let me look up the API docs for this method real quick.
When to use it: Researching during pairing
The UI looks great, but I think we should add some accessibility labels.
When to use it: Suggesting accessibility improvement
That error message isn't very helpful, let's make it more descriptive.
When to use it: Improving error messages
I think we should validate the input before processing it.
When to use it: Suggesting validation
Can you try resizing the window to see if the layout adapts?
When to use it: Testing responsive design
Great pairing session today! I feel like we made solid progress.
When to use it: Wrapping up
Should we use a constant for this magic number?
When to use it: Suggesting code clarity
I'm going to rubber duck this problem with you.
When to use it: Describing debugging technique
Let's revert that last change, it introduced a regression.
When to use it: Suggesting revert
This code is really clean, we should keep this standard going forward.
When to use it: Praising code quality
Let me quickly search for similar implementations in our codebase.
When to use it: Researching existing code
Let's add a breakpoint here and inspect the state at runtime.
When to use it: Debugging technique
Should we switch who's driving? Fresh eyes might help.
When to use it: Suggesting role swap
Let's create a separate branch so we can experiment without risk.
When to use it: Managing risk
Nice, we just saved ourselves hours of debugging with that test.
When to use it: Appreciating test value
This is a common pattern in our codebase, let me show you an example.
When to use it: Teaching by example
I'm going to add a TODO here so we remember to come back to this.
When to use it: Marking work for later
Let's add some logging here to help us debug this in production.
When to use it: Suggesting observability
Let's add some inline comments to clarify the logic
When to use it: Improving code readability
Let's create a branch before we start experimenting
When to use it: Setting up version control for experimentation
We forgot to update the changelog after merging
When to use it: Maintaining project documentation
Let me zoom out and explain the big picture first
When to use it: Providing context before diving into details
Can you pair with me on this migration script?
When to use it: Requesting help with database migration
Let's pair on the code review for this pull request
When to use it: Reviewing code together before merge
I'll navigate while you drive for the next thirty minutes
When to use it: Switching pair programming roles
This looks correct but let's verify with a print statement
When to use it: Quick debugging technique
Shall we set up a quick standup before diving into the code?
When to use it: Aligning before starting a pairing session
Let's commit this working state before we start the refactor
When to use it: Saving progress before making changes
I just pushed the fix, can you pull and verify it works?
When to use it: Asking pair to validate a fix
This switch statement needs a default case for safety
When to use it: Adding exhaustive handling in switch
Let's use the debugger breakpoints instead of print statements
When to use it: Using proper debugging tools
Nice solution, I wouldn't have thought of using that approach
When to use it: Praising creative problem solving
We're going in circles, let's take a step back and rethink
When to use it: Recognizing when to change approach
This looks good to me, let's move on to the next task
When to use it: Approving code and progressing
Let me create a playground to prototype this algorithm
When to use it: Using Swift Playgrounds for quick experiments
Can we run the test suite before we push these changes?
When to use it: Ensuring quality before sharing code
I think there's a simpler way to achieve the same result
When to use it: Suggesting code simplification
Let's document the expected behavior in a comment block
When to use it: Adding documentation for complex logic
I'll set up the project while you read the specifications
When to use it: Efficiently dividing prep work
Let's make sure the dark mode colors look right on this screen
When to use it: Verifying dark mode visual consistency
Intermediate phrases (112)
Let's take a step back and look at the bigger picture.
When to use it: Suggesting to zoom out and consider the overall design during pairing
Should we switch roles now? I'd like to try driving.
When to use it: Requesting a role swap during a pair programming session
I see a potential bug there. Can you scroll up?
When to use it: Spotting an issue while navigating and asking the driver to scroll
I think we should refactor this while we're here.
When to use it: Suggesting an improvement to the code during a pairing session
Let's put a breakpoint there and debug it together.
When to use it: Proposing to debug an issue collaboratively during pairing
I'm not sure I follow. Can you walk me through your reasoning?
When to use it: Asking the navigator or driver to explain their thought process
I'm going to type this out, and you tell me if you see any issues.
When to use it: Driver asking the navigator to actively review code as it's written
Let's commit what we have and continue from here after a break.
When to use it: Suggesting to save progress and take a break during a long pairing session
I have an idea, but I'm not sure it'll work. Let me try it out quickly.
When to use it: Proposing to experiment with an uncertain solution during pairing
Let's trace through this code step by step to find the issue.
When to use it: Suggesting a methodical debugging approach during pair programming
Let's try ping pong pairing — I'll write a failing test and you make it pass.
When to use it: Proposing the ping pong TDD technique where partners alternate writing tests and implementations
I think we should mob on this — let's pull in the rest of the team.
When to use it: Suggesting mob programming when the problem requires more perspectives
I'm just going to rubber duck this with you for a minute.
When to use it: Using your pair as a sounding board to talk through a problem
Let's add a breakpoint here and step through the code together.
When to use it: Collaborative debugging during a pair programming session
I notice we keep going back and forth — let's just pick one approach and commit to it.
When to use it: Resolving indecision during pairing by agreeing on a direction
Can you explain why you chose that data structure? I want to understand the reasoning.
When to use it: Asking your pair to explain a technical decision for learning purposes
I think we're overcomplicating this — what's the simplest solution that could work?
When to use it: Encouraging simplicity when the pair is going down a complex path
Great, the tests are green. Let's refactor before moving on.
When to use it: Following the red-green-refactor TDD cycle during pairing
I'm going to extract this into a helper function while you write the next test.
When to use it: Dividing work during a pairing session for efficiency
I see what you're doing, but wouldn't it be cleaner to use a map instead of a for loop?
When to use it: Suggesting a more idiomatic approach while navigating
I just realized we're solving the wrong problem. Let's re-read the ticket.
When to use it: Course-correcting when the pair has gone off track
Let's run the linter before we commit — I want to keep the diff clean.
When to use it: Maintaining code quality standards during pair programming
I'll handle the API integration part while you set up the database schema.
When to use it: Splitting work between partners on independent tasks
I think the bug is in the callback. Let's add some console logs and trace the data flow.
When to use it: Collaborative debugging with logging during pair programming
Good idea. Let's spike on that for fifteen minutes and see if it's viable.
When to use it: Agreeing to timebox an experimental investigation during pairing
The navigator should be thinking about the big picture while the driver focuses on the code.
When to use it: Explaining the responsibilities of each role in pair programming
That's a clever use of destructuring. I'm going to start using that in my own code.
When to use it: Complimenting and learning from your pair's coding style
Let's not gold-plate this. It meets the requirements — we can optimize later if needed.
When to use it: Preventing over-engineering during a pairing session
I notice we have some code duplication between these two methods. Should we extract a shared helper?
When to use it: Identifying DRY violations during collaborative code review
I think we should write a unit test for this edge case before we forget about it.
When to use it: Proactively adding test coverage during collaborative development
We should document this workaround with a comment explaining why it's necessary.
When to use it: Ensuring non-obvious code decisions are documented during pairing
I disagree with that approach, but let's try it your way first. If it doesn't work, we'll pivot.
When to use it: Constructively disagreeing while remaining collaborative
I see you're using an extension method there. Can you show me how you defined it?
When to use it: Learning about a language feature from your pair partner
I'm going to stash my changes so we can start from a clean state.
When to use it: Resetting the working directory during collaborative debugging
Can we step through this with the debugger? I want to inspect the state at each step.
When to use it: Using a debugger collaboratively to understand program behavior
Let's write the happy path first, then handle the error cases one by one.
When to use it: Prioritizing the main flow before edge cases during implementation
I think we're in a rabbit hole. Let's time-box this to ten more minutes and then reassess.
When to use it: Recognizing when the pair is spending too long on a tangent
Can you explain the business logic behind this requirement? I want to make sure our implementation is correct.
When to use it: Seeking domain understanding during collaborative implementation
Let's use a feature branch and make small, atomic commits as we go.
When to use it: Setting up version control strategy for a pairing session
I'll set up the database migration while you scaffold the new endpoint.
When to use it: Efficiently dividing parallel tasks during a pairing session
I've seen this pattern cause issues in production before. Let me tell you what happened.
When to use it: Sharing past experience to prevent potential problems
That null check won't be enough — what if the array is empty but not null?
When to use it: Catching subtle bugs by questioning assumptions during pairing
Let's compare our local changes against main to make sure we haven't drifted too far.
When to use it: Keeping the branch in sync during extended pairing sessions
Let's keep the scope tight. If we find something unrelated, we file a separate ticket.
When to use it: Maintaining focus and avoiding scope creep during pairing
The response payload is huge. Let's add pagination to avoid loading everything at once.
When to use it: Identifying performance improvements during collaborative API development
I think we should write the test first before implementing.
When to use it: Suggesting TDD approach
I see what you're doing, but what about the edge case where the input is empty?
When to use it: Identifying edge case
This function is getting too long, should we extract a helper?
When to use it: Suggesting refactoring
I'm not sure about this approach, can we discuss the trade-offs?
When to use it: Opening discussion
I think we're overcomplicating this. Let's step back and simplify.
When to use it: Suggesting simplification
What if we mock this dependency to make the test simpler?
When to use it: Suggesting test strategy
I'm following your logic, but I think we need to handle the error case too.
When to use it: Adding to partner's thinking
We should handle both the success and failure callbacks.
When to use it: Identifying missing logic
I'm confused about the data flow here, can we trace it step by step?
When to use it: Asking for clarification
Before we refactor, let's make sure we have tests covering the current behavior.
When to use it: Ensuring safety
I'm thinking out loud here, but what if we used a protocol for this?
When to use it: Brainstorming
Let's look at the stack trace to find where the error originates.
When to use it: Debugging together
I think we need to think about the performance implications of this.
When to use it: Raising performance concern
I agree with the overall design, but I have a suggestion for the error handling.
When to use it: Providing nuanced feedback
I see you're using a for loop here, would a map be more readable?
When to use it: Suggesting functional approach
Let's write a quick spike to validate our approach before going all in.
When to use it: Suggesting validation
Interesting, the API returns different formats depending on the locale.
When to use it: Discovering unexpected behavior
Let me share my screen so you can see the issue
When to use it: Starting a debugging session together
Can you walk me through how this middleware works?
When to use it: Understanding middleware layer together
I think we should add a guard clause here
When to use it: Suggesting early return pattern
This function is doing too many things at once
When to use it: Identifying single responsibility violations
Let me pull up the API documentation for this endpoint
When to use it: Referencing docs during implementation
We should extract this into a utility function
When to use it: Suggesting code reuse
I'll handle the UI while you work on the data layer
When to use it: Dividing work in parallel pairing
Can you double-check that the error handling covers all edge cases?
When to use it: Reviewing error scenarios together
This regex is getting complex, let's break it down
When to use it: Simplifying regular expressions together
The naming convention here doesn't match the rest of the codebase
When to use it: Maintaining code consistency
Should we add a loading state indicator while this processes?
When to use it: Discussing UX improvements
I notice we're not handling the optional unwrapping safely here
When to use it: Pointing out force unwrap risks
Let's write the test first and then implement the feature
When to use it: Doing test-driven development
This method signature is getting too long, can we simplify it?
When to use it: Refactoring method parameters
I think we need to add input validation before processing
When to use it: Adding data validation checks
Can you show me how you'd approach this algorithm?
When to use it: Learning from pair's problem-solving approach
Let's review the database schema before writing the queries
When to use it: Planning database work together
Let me trace through the data flow to find the bug
When to use it: Debugging by following data transformation
I see redundant code here, let's DRY it up
When to use it: Removing code duplication
Can you check if this endpoint handles pagination correctly?
When to use it: Verifying API pagination implementation
Let's add proper logging before deploying this
When to use it: Ensuring observability in production
This component should be more reusable across the app
When to use it: Improving component reusability
I found the root cause, it's in the data mapping layer
When to use it: Identifying bug source during debugging
We need to handle the case where the API returns an empty response
When to use it: Adding empty state handling
This enum should be exhaustive to prevent future bugs
When to use it: Ensuring complete switch case coverage
Let's make sure this works with VoiceOver enabled
When to use it: Testing accessibility features
Can we add a feature flag so we can toggle this safely?
When to use it: Implementing gradual rollout
Let's sketch out the class diagram on the whiteboard first
When to use it: Planning before coding
We should mock this external service for the unit tests
When to use it: Setting up test doubles
Let's refactor this before adding the new feature on top
When to use it: Preparing codebase for new feature
I think we should split this view into smaller subviews
When to use it: Breaking down large SwiftUI views
We need to update the snapshot tests after this UI change
When to use it: Maintaining visual regression tests
Great catch, I didn't notice that off-by-one error
When to use it: Acknowledging pair's contribution during debugging
This error message isn't helpful for debugging, let's improve it
When to use it: Making error messages more descriptive
We should add accessibility labels to these custom controls
When to use it: Improving accessibility in custom UI
Let's discuss the tradeoffs between these two approaches
When to use it: Comparing implementation strategies
The localization keys are inconsistent, let's standardize them
When to use it: Cleaning up i18n key naming
We should wrap this network call in a do-catch block
When to use it: Adding proper error handling to async code
I'll document the decision we just made in the ADR
When to use it: Recording architectural decisions
Should we use @StateObject or @ObservedObject here?
When to use it: Choosing the right SwiftUI property wrapper
Let's add unit tests for these edge cases we just found
When to use it: Writing tests for discovered edge cases
Can you verify that the data persistence works after force quit?
When to use it: Testing data durability
We need to handle the keyboard dismissal properly in this form
When to use it: Managing keyboard behavior in iOS forms
This extension method would be useful in other parts of the app too
When to use it: Recognizing reusable utility code
Let's add a debug overlay to visualize the layout frames
When to use it: Using visual debugging for layout issues
The animation timing doesn't feel right, let's tweak the curve
When to use it: Fine-tuning animation parameters
We should sanitize this user input before storing it
When to use it: Preventing injection attacks
Let's align on the acceptance criteria before coding
When to use it: Ensuring shared understanding of requirements
This JSON parsing could fail silently, let's add error logging
When to use it: Improving error visibility in data parsing
Let's use environment values instead of passing this through every view
When to use it: Using SwiftUI environment for dependency injection
Advanced phrases (60)
Let's try a different approach. What if we use a strategy pattern here?
When to use it: Suggesting an alternative design pattern during collaborative coding
We should probably extract this into its own method for readability.
When to use it: Suggesting a refactoring to improve code readability during pairing
Wait, I think there's a race condition here. Let's look at this more carefully.
When to use it: Catching a concurrency issue during collaborative debugging
The variable naming here is a bit confusing. How about we rename it to something more descriptive?
When to use it: Suggesting better naming conventions during a pairing session
We could try mob programming on this. Let's invite the rest of the team.
When to use it: Suggesting to expand the pairing session into a mob programming session
This edge case is tricky. Let's write down all the scenarios before coding.
When to use it: Suggesting to plan edge cases before implementing during pairing
I agree with the logic, but I think we should add some error handling here.
When to use it: Suggesting improvements while agreeing with the overall approach
Nice, that's much cleaner now. Let's run the tests to make sure we didn't break anything.
When to use it: Approving a refactoring and suggesting verification after changes
Hold on, let me check the documentation before we go down that path.
When to use it: Pausing to verify an assumption by checking docs during pairing
That was a productive session. Let's summarize what we accomplished and create tickets for the remaining work.
When to use it: Wrapping up a pair programming session and documenting outcomes
Wait, I think there's a race condition here. Let's trace through the execution order.
When to use it: Spotting a concurrency bug during collaborative debugging
This is getting complex. Let's draw a sequence diagram to map out the flow.
When to use it: Using diagrams to visualize complex logic during pairing
That if-else chain is getting long. What do you think about using a switch or a strategy pattern?
When to use it: Suggesting a refactoring opportunity while reviewing code together
I think we need to step back and agree on the interface before implementing the details.
When to use it: Advocating for design-first approach during collaborative coding
Let's mock this external API so we can test our code without depending on the third-party service.
When to use it: Setting up mocks during collaborative test writing
That error message is misleading. The actual problem is two levels deeper in the stack trace.
When to use it: Helping your pair identify the root cause during debugging
I think the integration test is more valuable here than a unit test. Let's test the whole flow.
When to use it: Discussing testing strategy during collaborative development
Instead of fixing this bug, let's write a regression test that reproduces it first.
When to use it: Following test-first approach for bug fixing during pairing
This dependency injection setup is getting messy. Let's refactor it before adding more services.
When to use it: Addressing technical debt during a pairing session
Let's check the performance impact of this change by running the benchmark suite.
When to use it: Verifying performance during collaborative optimization work
The API contract says it returns an array, but we're handling it as a single object. That's the bug.
When to use it: Identifying a contract mismatch during collaborative debugging
I think the problem is in how we're serializing the date. Let me check the timezone handling.
When to use it: Investigating date/time bugs during collaborative debugging
I think we should use dependency injection here so this is easier to test.
When to use it: Suggesting architectural improvements for testability during pairing
I think we need to add error boundaries around this component to handle rendering failures gracefully.
When to use it: Discussing resilience patterns during UI development in pairing
This pattern reminds me of the strategy pattern, should we formalize it?
When to use it: Identifying design pattern
I think this closure is capturing self strongly, which could cause a retain cycle.
When to use it: Identifying memory issue
This logic would be clearer as a state machine.
When to use it: Suggesting design pattern
Wait, there's a race condition here. Two threads could modify this at the same time.
When to use it: Catching concurrency bug
Can you explain the reasoning behind this design pattern?
When to use it: Understanding architectural decisions
I spotted a potential memory leak in this closure
When to use it: Identifying memory management issues
This looks like it could cause a race condition
When to use it: Identifying concurrency issues
Should we use dependency injection here instead?
When to use it: Discussing testability improvements
Let's step back and think about the overall architecture
When to use it: Taking a high-level view of the system
Have you considered using a protocol-oriented approach?
When to use it: Suggesting Swift design patterns
I think this test is too tightly coupled to the implementation
When to use it: Discussing test quality
The cyclomatic complexity of this function is too high
When to use it: Identifying overly complex code
I think this would benefit from the strategy pattern
When to use it: Suggesting design pattern application
This async call should have a timeout to prevent hanging
When to use it: Adding resilience to async operations
We should benchmark this before and after the optimization
When to use it: Measuring performance improvements
I think we should use a state machine for this flow
When to use it: Suggesting state management approach
The build is failing because of a circular dependency
When to use it: Diagnosing compilation issues together
I notice this uses a deprecated API that will break in the next version
When to use it: Flagging deprecated usage
This seems like a good candidate for memoization
When to use it: Optimizing repeated calculations
This computed property is being called too frequently in the view
When to use it: Identifying performance issues in SwiftUI
The animation feels janky, let's check the main thread usage
When to use it: Debugging UI performance issues
We should add a retry mechanism with exponential backoff
When to use it: Implementing resilient network calls
Let me explain what this closure captures and why it matters
When to use it: Teaching about capture lists in Swift
Can you help me understand how the generic constraints work here?
When to use it: Learning about Swift generics together
Let's use the profiler to identify the performance bottleneck
When to use it: Using Instruments for performance analysis
We should consider thread safety for this shared resource
When to use it: Discussing concurrent access to shared data
I see that the view model is retaining a strong reference to the view
When to use it: Identifying retain cycles in MVVM
Can you explain what @MainActor does in this context?
When to use it: Learning about Swift concurrency annotations
I suggest we add a caching layer to reduce API calls
When to use it: Optimizing network usage
Let's check the memory graph to find the leak
When to use it: Using Xcode Memory Graph Debugger
This initializer has too many parameters, let's use a builder pattern
When to use it: Simplifying object creation
I think the issue is related to the view lifecycle timing
When to use it: Debugging SwiftUI view lifecycle issues
This property observer is causing an infinite update loop
When to use it: Debugging didSet/willSet issues
We should consider backward compatibility for users on older iOS versions
When to use it: Planning for multi-version support
We should use weak self in this closure to avoid retain cycles
When to use it: Preventing memory leaks in closures
I think we should handle the cancellation task properly here
When to use it: Managing task cancellation in Swift concurrency
Other everyday developer situations
- Daily standup280 phrases
- Code review275 phrases
- Pull requests300 phrases
- Bug reports300 phrases
- Meetings300 phrases
- Job interviews300 phrases
- Slack and chat300 phrases
- Email298 phrases
- Technical discussions299 phrases
- Polite phrases300 phrases
- Documentation300 phrases
Guides with more context
Take it to your phone
In the Devlingo app you get 10 new phrases a day, each with real-world context, pronunciation and examples, and the widget shows the phrase of the day on your iPhone Home Screen.