English for developers · Pair programming

Pair programming phrases for your next session

Quick answer

In pair programming you talk while you code, and that calls for short phrases: explaining what you are doing, suggesting an idea, switching who types and asking for a break. We picked 300 pair programming phrases from the Devlingo app, with context and audio, for your next session.

Updated

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)

  1. Do you want to drive or navigate?

    When to use it: Deciding roles at the start of a pair programming session

  2. I'll drive first, and we can switch in 20 minutes.

    When to use it: Setting up a rotation schedule for pair programming roles

  3. Can you share your screen?

    When to use it: Asking your pair to share their screen for a remote session

  4. Let me think out loud for a second.

    When to use it: Pausing to verbalize your thought process to your pair

  5. What do you think about this approach?

    When to use it: Asking your pair for feedback on a proposed solution

  6. Can you explain what this function does?

    When to use it: Asking your pair to walk you through unfamiliar code

  7. Let's write a test for this before we move on.

    When to use it: Suggesting to add a test while pairing before proceeding

  8. Good catch! I wouldn't have noticed that.

    When to use it: Acknowledging when your pair spots a mistake or improvement

  9. 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

  10. 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

  11. 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

  12. 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

  13. 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

  14. Nice catch! I totally missed that edge case.

    When to use it: Acknowledging when your pair spots a bug or oversight you missed

  15. 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

  16. 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

  17. 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

  18. 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

  19. 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

  20. 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

  21. 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

  22. 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

  23. 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

  24. 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

  25. 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

  26. 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

  27. 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

  28. 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

  29. 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

  30. 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

  31. 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

  32. 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

  33. 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

  34. 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

  35. 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

  36. 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

  37. 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

  38. 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

  39. 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

  40. 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

  41. 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

  42. 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

  43. 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

  44. 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

  45. 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

  46. 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

  47. 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

  48. 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

  49. 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

  50. 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

  51. 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

  52. Can you walk me through what you're thinking here?

    When to use it: Asking for explanation while pairing

  53. Let me take over the keyboard for a bit.

    When to use it: Switching driver role

  54. That's a clever solution, I wouldn't have thought of that.

    When to use it: Giving positive feedback

  55. Let's break this problem down into smaller pieces.

    When to use it: Suggesting approach

  56. Should we commit what we have so far before continuing?

    When to use it: Suggesting incremental progress

  57. Can you zoom in on that part of the code? I can't read it clearly.

    When to use it: Asking for visibility

  58. Let's add a comment here to explain why we're doing this.

    When to use it: Suggesting documentation

  59. I think there's a simpler way to do this, let me show you.

    When to use it: Suggesting alternative

  60. Wait, I think we introduced a bug. Let me scroll back.

    When to use it: Catching a mistake

  61. Good catch! I completely missed that null check.

    When to use it: Acknowledging partner's contribution

  62. Let me run the tests to make sure we didn't break anything.

    When to use it: Verifying changes

  63. Let's use the debugger to step through this code.

    When to use it: Suggesting debugging approach

  64. Can you explain the business logic behind this feature?

    When to use it: Asking for context

  65. Let's look at the documentation for this library before using it.

    When to use it: Suggesting research

  66. Your idea is better than mine, let's go with your approach.

    When to use it: Deferring to partner

  67. I'm getting a compile error on this line, can you spot the issue?

    When to use it: Asking for help with error

  68. Let's take a five-minute break, I need to clear my head.

    When to use it: Suggesting a break

  69. I learned something new from you today, thanks for sharing.

    When to use it: Expressing gratitude for learning

  70. Can you share your screen? The audio is fine but I can't see the code.

    When to use it: Technical setup

  71. Let's try the other approach and see if the tests pass.

    When to use it: Suggesting experimentation

  72. I noticed a typo in the variable name, should be camelCase.

    When to use it: Catching naming error

  73. Nice, the test is green. Let's move on to the next scenario.

    When to use it: Celebrating progress

  74. I don't think we need this import, it's unused.

    When to use it: Catching unnecessary code

  75. Let me draw a diagram to explain what I'm thinking.

    When to use it: Visual communication

  76. Let's look at how the existing code handles this case.

    When to use it: Suggesting reference

  77. This is a good learning opportunity, take your time with it.

    When to use it: Encouraging learning

  78. Let's timebox this to 30 minutes and reassess if we're stuck.

    When to use it: Managing time

  79. I think the naming could be more descriptive, what about calling it processPayment?

    When to use it: Suggesting naming improvement

  80. Can you explain this algorithm to me? I want to make sure I understand it.

    When to use it: Asking for knowledge transfer

  81. Let's use print statements to debug this quickly.

    When to use it: Suggesting quick debugging

  82. That's a great refactoring, the code reads much better now.

    When to use it: Giving positive feedback

  83. Should we add a guard clause at the top of this function?

    When to use it: Suggesting defensive coding

  84. Let's commit this working version and then optimize later.

    When to use it: Prioritizing progress

  85. Interesting approach, I've never seen it done that way before.

    When to use it: Acknowledging novelty

  86. The linter is complaining about the line length, can we split this?

    When to use it: Following code standards

  87. I'll type the test, you tell me what assertions we need.

    When to use it: Dividing pairing tasks

  88. We should probably create a feature branch for this.

    When to use it: Suggesting git workflow

  89. Let me look up the API docs for this method real quick.

    When to use it: Researching during pairing

  90. The UI looks great, but I think we should add some accessibility labels.

    When to use it: Suggesting accessibility improvement

  91. That error message isn't very helpful, let's make it more descriptive.

    When to use it: Improving error messages

  92. I think we should validate the input before processing it.

    When to use it: Suggesting validation

  93. Can you try resizing the window to see if the layout adapts?

    When to use it: Testing responsive design

  94. Great pairing session today! I feel like we made solid progress.

    When to use it: Wrapping up

  95. Should we use a constant for this magic number?

    When to use it: Suggesting code clarity

  96. I'm going to rubber duck this problem with you.

    When to use it: Describing debugging technique

  97. Let's revert that last change, it introduced a regression.

    When to use it: Suggesting revert

  98. This code is really clean, we should keep this standard going forward.

    When to use it: Praising code quality

  99. Let me quickly search for similar implementations in our codebase.

    When to use it: Researching existing code

  100. Let's add a breakpoint here and inspect the state at runtime.

    When to use it: Debugging technique

  101. Should we switch who's driving? Fresh eyes might help.

    When to use it: Suggesting role swap

  102. Let's create a separate branch so we can experiment without risk.

    When to use it: Managing risk

  103. Nice, we just saved ourselves hours of debugging with that test.

    When to use it: Appreciating test value

  104. This is a common pattern in our codebase, let me show you an example.

    When to use it: Teaching by example

  105. I'm going to add a TODO here so we remember to come back to this.

    When to use it: Marking work for later

  106. Let's add some logging here to help us debug this in production.

    When to use it: Suggesting observability

  107. Let's add some inline comments to clarify the logic

    When to use it: Improving code readability

  108. Let's create a branch before we start experimenting

    When to use it: Setting up version control for experimentation

  109. We forgot to update the changelog after merging

    When to use it: Maintaining project documentation

  110. Let me zoom out and explain the big picture first

    When to use it: Providing context before diving into details

  111. Can you pair with me on this migration script?

    When to use it: Requesting help with database migration

  112. Let's pair on the code review for this pull request

    When to use it: Reviewing code together before merge

  113. I'll navigate while you drive for the next thirty minutes

    When to use it: Switching pair programming roles

  114. This looks correct but let's verify with a print statement

    When to use it: Quick debugging technique

  115. Shall we set up a quick standup before diving into the code?

    When to use it: Aligning before starting a pairing session

  116. Let's commit this working state before we start the refactor

    When to use it: Saving progress before making changes

  117. I just pushed the fix, can you pull and verify it works?

    When to use it: Asking pair to validate a fix

  118. This switch statement needs a default case for safety

    When to use it: Adding exhaustive handling in switch

  119. Let's use the debugger breakpoints instead of print statements

    When to use it: Using proper debugging tools

  120. Nice solution, I wouldn't have thought of using that approach

    When to use it: Praising creative problem solving

  121. We're going in circles, let's take a step back and rethink

    When to use it: Recognizing when to change approach

  122. This looks good to me, let's move on to the next task

    When to use it: Approving code and progressing

  123. Let me create a playground to prototype this algorithm

    When to use it: Using Swift Playgrounds for quick experiments

  124. Can we run the test suite before we push these changes?

    When to use it: Ensuring quality before sharing code

  125. I think there's a simpler way to achieve the same result

    When to use it: Suggesting code simplification

  126. Let's document the expected behavior in a comment block

    When to use it: Adding documentation for complex logic

  127. I'll set up the project while you read the specifications

    When to use it: Efficiently dividing prep work

  128. 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)

  1. 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

  2. Should we switch roles now? I'd like to try driving.

    When to use it: Requesting a role swap during a pair programming session

  3. 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

  4. I think we should refactor this while we're here.

    When to use it: Suggesting an improvement to the code during a pairing session

  5. Let's put a breakpoint there and debug it together.

    When to use it: Proposing to debug an issue collaboratively during pairing

  6. 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

  7. 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

  8. 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

  9. 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

  10. 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

  11. 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

  12. 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

  13. 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

  14. Let's add a breakpoint here and step through the code together.

    When to use it: Collaborative debugging during a pair programming session

  15. 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

  16. 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

  17. 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

  18. Great, the tests are green. Let's refactor before moving on.

    When to use it: Following the red-green-refactor TDD cycle during pairing

  19. 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

  20. 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

  21. 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

  22. 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

  23. 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

  24. 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

  25. 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

  26. 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

  27. 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

  28. 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

  29. 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

  30. 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

  31. 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

  32. 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

  33. 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

  34. 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

  35. 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

  36. 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

  37. 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

  38. 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

  39. 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

  40. 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

  41. 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

  42. 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

  43. 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

  44. 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

  45. 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

  46. I think we should write the test first before implementing.

    When to use it: Suggesting TDD approach

  47. I see what you're doing, but what about the edge case where the input is empty?

    When to use it: Identifying edge case

  48. This function is getting too long, should we extract a helper?

    When to use it: Suggesting refactoring

  49. I'm not sure about this approach, can we discuss the trade-offs?

    When to use it: Opening discussion

  50. I think we're overcomplicating this. Let's step back and simplify.

    When to use it: Suggesting simplification

  51. What if we mock this dependency to make the test simpler?

    When to use it: Suggesting test strategy

  52. 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

  53. We should handle both the success and failure callbacks.

    When to use it: Identifying missing logic

  54. I'm confused about the data flow here, can we trace it step by step?

    When to use it: Asking for clarification

  55. Before we refactor, let's make sure we have tests covering the current behavior.

    When to use it: Ensuring safety

  56. I'm thinking out loud here, but what if we used a protocol for this?

    When to use it: Brainstorming

  57. Let's look at the stack trace to find where the error originates.

    When to use it: Debugging together

  58. I think we need to think about the performance implications of this.

    When to use it: Raising performance concern

  59. I agree with the overall design, but I have a suggestion for the error handling.

    When to use it: Providing nuanced feedback

  60. I see you're using a for loop here, would a map be more readable?

    When to use it: Suggesting functional approach

  61. Let's write a quick spike to validate our approach before going all in.

    When to use it: Suggesting validation

  62. Interesting, the API returns different formats depending on the locale.

    When to use it: Discovering unexpected behavior

  63. Let me share my screen so you can see the issue

    When to use it: Starting a debugging session together

  64. Can you walk me through how this middleware works?

    When to use it: Understanding middleware layer together

  65. I think we should add a guard clause here

    When to use it: Suggesting early return pattern

  66. This function is doing too many things at once

    When to use it: Identifying single responsibility violations

  67. Let me pull up the API documentation for this endpoint

    When to use it: Referencing docs during implementation

  68. We should extract this into a utility function

    When to use it: Suggesting code reuse

  69. I'll handle the UI while you work on the data layer

    When to use it: Dividing work in parallel pairing

  70. Can you double-check that the error handling covers all edge cases?

    When to use it: Reviewing error scenarios together

  71. This regex is getting complex, let's break it down

    When to use it: Simplifying regular expressions together

  72. The naming convention here doesn't match the rest of the codebase

    When to use it: Maintaining code consistency

  73. Should we add a loading state indicator while this processes?

    When to use it: Discussing UX improvements

  74. I notice we're not handling the optional unwrapping safely here

    When to use it: Pointing out force unwrap risks

  75. Let's write the test first and then implement the feature

    When to use it: Doing test-driven development

  76. This method signature is getting too long, can we simplify it?

    When to use it: Refactoring method parameters

  77. I think we need to add input validation before processing

    When to use it: Adding data validation checks

  78. Can you show me how you'd approach this algorithm?

    When to use it: Learning from pair's problem-solving approach

  79. Let's review the database schema before writing the queries

    When to use it: Planning database work together

  80. Let me trace through the data flow to find the bug

    When to use it: Debugging by following data transformation

  81. I see redundant code here, let's DRY it up

    When to use it: Removing code duplication

  82. Can you check if this endpoint handles pagination correctly?

    When to use it: Verifying API pagination implementation

  83. Let's add proper logging before deploying this

    When to use it: Ensuring observability in production

  84. This component should be more reusable across the app

    When to use it: Improving component reusability

  85. I found the root cause, it's in the data mapping layer

    When to use it: Identifying bug source during debugging

  86. We need to handle the case where the API returns an empty response

    When to use it: Adding empty state handling

  87. This enum should be exhaustive to prevent future bugs

    When to use it: Ensuring complete switch case coverage

  88. Let's make sure this works with VoiceOver enabled

    When to use it: Testing accessibility features

  89. Can we add a feature flag so we can toggle this safely?

    When to use it: Implementing gradual rollout

  90. Let's sketch out the class diagram on the whiteboard first

    When to use it: Planning before coding

  91. We should mock this external service for the unit tests

    When to use it: Setting up test doubles

  92. Let's refactor this before adding the new feature on top

    When to use it: Preparing codebase for new feature

  93. I think we should split this view into smaller subviews

    When to use it: Breaking down large SwiftUI views

  94. We need to update the snapshot tests after this UI change

    When to use it: Maintaining visual regression tests

  95. Great catch, I didn't notice that off-by-one error

    When to use it: Acknowledging pair's contribution during debugging

  96. This error message isn't helpful for debugging, let's improve it

    When to use it: Making error messages more descriptive

  97. We should add accessibility labels to these custom controls

    When to use it: Improving accessibility in custom UI

  98. Let's discuss the tradeoffs between these two approaches

    When to use it: Comparing implementation strategies

  99. The localization keys are inconsistent, let's standardize them

    When to use it: Cleaning up i18n key naming

  100. We should wrap this network call in a do-catch block

    When to use it: Adding proper error handling to async code

  101. I'll document the decision we just made in the ADR

    When to use it: Recording architectural decisions

  102. Should we use @StateObject or @ObservedObject here?

    When to use it: Choosing the right SwiftUI property wrapper

  103. Let's add unit tests for these edge cases we just found

    When to use it: Writing tests for discovered edge cases

  104. Can you verify that the data persistence works after force quit?

    When to use it: Testing data durability

  105. We need to handle the keyboard dismissal properly in this form

    When to use it: Managing keyboard behavior in iOS forms

  106. This extension method would be useful in other parts of the app too

    When to use it: Recognizing reusable utility code

  107. Let's add a debug overlay to visualize the layout frames

    When to use it: Using visual debugging for layout issues

  108. The animation timing doesn't feel right, let's tweak the curve

    When to use it: Fine-tuning animation parameters

  109. We should sanitize this user input before storing it

    When to use it: Preventing injection attacks

  110. Let's align on the acceptance criteria before coding

    When to use it: Ensuring shared understanding of requirements

  111. This JSON parsing could fail silently, let's add error logging

    When to use it: Improving error visibility in data parsing

  112. 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)

  1. 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

  2. We should probably extract this into its own method for readability.

    When to use it: Suggesting a refactoring to improve code readability during pairing

  3. 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

  4. 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

  5. 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

  6. 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

  7. 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

  8. 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

  9. 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

  10. 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

  11. 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

  12. 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

  13. 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

  14. 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

  15. 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

  16. 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

  17. 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

  18. 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

  19. 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

  20. Let's check the performance impact of this change by running the benchmark suite.

    When to use it: Verifying performance during collaborative optimization work

  21. 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

  22. 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

  23. 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

  24. 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

  25. This pattern reminds me of the strategy pattern, should we formalize it?

    When to use it: Identifying design pattern

  26. I think this closure is capturing self strongly, which could cause a retain cycle.

    When to use it: Identifying memory issue

  27. This logic would be clearer as a state machine.

    When to use it: Suggesting design pattern

  28. Wait, there's a race condition here. Two threads could modify this at the same time.

    When to use it: Catching concurrency bug

  29. Can you explain the reasoning behind this design pattern?

    When to use it: Understanding architectural decisions

  30. I spotted a potential memory leak in this closure

    When to use it: Identifying memory management issues

  31. This looks like it could cause a race condition

    When to use it: Identifying concurrency issues

  32. Should we use dependency injection here instead?

    When to use it: Discussing testability improvements

  33. Let's step back and think about the overall architecture

    When to use it: Taking a high-level view of the system

  34. Have you considered using a protocol-oriented approach?

    When to use it: Suggesting Swift design patterns

  35. I think this test is too tightly coupled to the implementation

    When to use it: Discussing test quality

  36. The cyclomatic complexity of this function is too high

    When to use it: Identifying overly complex code

  37. I think this would benefit from the strategy pattern

    When to use it: Suggesting design pattern application

  38. This async call should have a timeout to prevent hanging

    When to use it: Adding resilience to async operations

  39. We should benchmark this before and after the optimization

    When to use it: Measuring performance improvements

  40. I think we should use a state machine for this flow

    When to use it: Suggesting state management approach

  41. The build is failing because of a circular dependency

    When to use it: Diagnosing compilation issues together

  42. I notice this uses a deprecated API that will break in the next version

    When to use it: Flagging deprecated usage

  43. This seems like a good candidate for memoization

    When to use it: Optimizing repeated calculations

  44. This computed property is being called too frequently in the view

    When to use it: Identifying performance issues in SwiftUI

  45. The animation feels janky, let's check the main thread usage

    When to use it: Debugging UI performance issues

  46. We should add a retry mechanism with exponential backoff

    When to use it: Implementing resilient network calls

  47. Let me explain what this closure captures and why it matters

    When to use it: Teaching about capture lists in Swift

  48. Can you help me understand how the generic constraints work here?

    When to use it: Learning about Swift generics together

  49. Let's use the profiler to identify the performance bottleneck

    When to use it: Using Instruments for performance analysis

  50. We should consider thread safety for this shared resource

    When to use it: Discussing concurrent access to shared data

  51. I see that the view model is retaining a strong reference to the view

    When to use it: Identifying retain cycles in MVVM

  52. Can you explain what @MainActor does in this context?

    When to use it: Learning about Swift concurrency annotations

  53. I suggest we add a caching layer to reduce API calls

    When to use it: Optimizing network usage

  54. Let's check the memory graph to find the leak

    When to use it: Using Xcode Memory Graph Debugger

  55. This initializer has too many parameters, let's use a builder pattern

    When to use it: Simplifying object creation

  56. I think the issue is related to the view lifecycle timing

    When to use it: Debugging SwiftUI view lifecycle issues

  57. This property observer is causing an infinite update loop

    When to use it: Debugging didSet/willSet issues

  58. We should consider backward compatibility for users on older iOS versions

    When to use it: Planning for multi-version support

  59. We should use weak self in this closure to avoid retain cycles

    When to use it: Preventing memory leaks in closures

  60. I think we should handle the cancellation task properly here

    When to use it: Managing task cancellation in Swift concurrency

Other everyday developer situations

← English for developers

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.

Frequently asked questions

What people ask most about this, answered with the source.

What are driver and navigator in pair programming?
The driver is at the keyboard; the navigator reviews and thinks about the next step. You switch every task or every 25 minutes.
How do you suggest something without taking the keyboard?
What if we tried…? or Can I suggest something?, and let the driver decide.
DevlingoLearn tech phrases & speaking
Use without installingGet