Prepositions That Trip Up Developers in English

Prepositions are one of the last things non-native speakers fully master in English, because they rarely follow a clean rule — you mostly just have to know that it’s “depend on,” not “depend from” or “depend of,” even though other languages use a different preposition for the same idea. This guide collects the technical-English preposition pairs developers get wrong most often, with the correct usage in context.

Key Vocabulary

Depend on (not “depend of/from”) — used when one thing relies on or is determined by another; a very common error is borrowing the preposition from a Romance-language equivalent. “The rollout timeline depends on how quickly QA can finish regression testing — not ‘depends of,’ even though that’s the pattern in several other languages.”

Responsible for (not “responsible of”) — used to describe ownership of a task, system, or outcome. “She’s responsible for the payments service end-to-end, from the API to the reconciliation job.”

Consist of (not “consist in” or “consist from”) — used to describe what components make up a system. “The pipeline consists of three stages: ingestion, transformation, and load.”

Agree with / Agree on — “agree with” a person or an idea; “agree on” a specific decision or plan the group reaches together. “I agree with your assessment of the risk, and I think we agree on the mitigation plan too.”

Compare to / Compare with — “compare to” highlights similarity between different types of things; “compare with” is used for a detailed, side-by-side comparison of similar things (in practice, native speakers use these somewhat interchangeably, but “compare to” is more common in casual technical speech). “Compared to last quarter, our error rate dropped significantly.”

Common Phrases

• “This service depends on the auth service being available.”
• “Who’s responsible for maintaining this repository?”
• “The system consists of a frontend, an API layer, and a database.”
• “I agree with the overall direction, but I don’t fully agree on the timeline.”
• “Compared to the old version, this is noticeably faster.”

Example Sentences

Using “depend on” correctly in a design discussion: “The whole caching strategy depends on how often the underlying data actually changes — if it’s mostly static, we can cache much more aggressively.”

Using “responsible for” to clarify ownership: “Just to be clear on ownership: the platform team is responsible for the CI infrastructure, and each service team is responsible for their own test suites.”

Describing system composition with “consist of”: “Our deployment pipeline consists of a build stage, an automated test stage, and a manual approval gate before production.”

Distinguishing “agree with” from “agree on”: “I agree with the concern about latency, but I don’t think we fully agree on how urgent it is — I’d put it as a next-quarter fix, not a this-week fix.”

Professional Tips

• “Depend on” is the single most common preposition error for speakers of Romance and Slavic languages — drill this one specifically, since it appears constantly in design discussions.
• “Responsible for” always takes “for,” never “of” — a small error, but one native speakers notice immediately.
• “Consist of” describes composition; don’t confuse it with “consist in,” which is rare and mostly literary/formal, not used in tech contexts.
• Distinguish “agree with” (a person, an idea) from “agree on” (a shared decision) — you can agree with someone’s reasoning while still not agreeing on the final call.
• When in doubt, listen for the preposition in native speakers’ sentences rather than translating from your own language — prepositions are learned by pattern exposure more than by rule.

Practice Exercise

1. Write three sentences using “depend on” correctly in a technical context.
2. Write a sentence distinguishing “agree with” from “agree on” in the same discussion.
3. Describe the components of a system you work on using “consists of.”

In Practice: Prepositions and Collaboration

Many of the prepositions we discuss – dependent on, in agreement with, accountable for – aren’t just about grammatical accuracy; they’re crucial signals in professional communication. When a non-native speaker encounters these phrases, it’s not simply that they’re “wrong.” It’s often that the subtle nuances of usage haven’t been fully absorbed, leading to misunderstandings and potentially impacting collaboration within a team. For example, saying “I’m responsible for this feature” can feel quite weighty, implying sole ownership, whereas stating “I’m accountable for ensuring this component functions correctly” conveys a more collaborative approach focused on outcomes. Similarly, “agreeing with” the proposed design might sound passive; framing it as “aligning with the design principles” suggests a deeper engagement and understanding of the broader context.

The challenge often lies in translating literal meanings from one’s native language into English. A developer accustomed to saying “I depend on your feedback” might inadvertently create an expectation of constant, immediate attention. A more natural phrasing – “I rely on your feedback for validation” – subtly shifts the focus to a process and acknowledges that the feedback is part of a larger workflow. These differences aren’t about pedantry; they’re about establishing clear expectations and fostering productive conversations. During code reviews, for instance, pointing out a bug with “This is broken because of…” can sound accusatory. Instead, “This component isn’t functioning as expected due to this condition” demonstrates a more analytical approach and invites discussion rather than defensiveness. It’s vital to remember that professional English prioritizes precision and clarity, minimizing ambiguity and maximizing the potential for effective teamwork.

Furthermore, consider PR descriptions – a critical area where prepositional phrases frequently appear. A poorly worded description like “Implemented this feature in the main branch” lacks context and doesn’t convey the impact of the change. A more descriptive alternative might be: “Merged this new user authentication flow into the production branch, addressing identified security vulnerabilities.” The latter clearly states where the changes were deployed and why, providing valuable information for reviewers and future maintenance. Mastering these subtle distinctions allows developers to communicate their ideas confidently and contribute meaningfully to team discussions.

Here’s an example of how pytest can be used to test a function that incorporates prepositions:

import pytest

def calculate_discount(price, discount_percentage):
  """Calculates the discounted price."""
  if discount_percentage <= 0:
    return price # No discount applied
  elif discount_percentage >= 100:
    return 0 # Price is fully discounted
  else:
    discounted_amount = (discount_percentage / 100) * price
    return price - discounted_amount

def test_calculate_discount():
  assert calculate_discount(100, 20) == 80.0
  assert calculate_discount(50, 100) == 0.0
  assert calculate_discount(75, 0) == 75.0