Table of Contents
- Making Statements and Calling Them Suggestions
- Communicating Conclusions Without Reasoning
- Criticizing Something Without Explaining Why It Is Bad
- Expecting People to Reverse-Engineer Your Thoughts
- Confusing Requirements With Preferences
- Asking Poorly Framed Questions
- Reporting Problems Without Providing Information
- Disagreeing Without Identifying the Actual Disagreement
- Mistaking Confidence for Competence
- Not Communicating Ownership and Responsibility
- Communicating Too Late
- Failing to Say No Clearly
- Waiting for Someone Instead of Communicating Expectations
- Attacking People Instead of Evaluating Ideas
- Using Technical Jargon to Appear Intelligent
- Holding Meetings Without Producing Decisions
- Giving Instructions Without Defining Success
- Not Documenting Why Decisions Were Made
- Confusing Communication Skills With Speaking Fluent English
- Communication Debt Compounds Like Technical Debt
- Treat Communication Like an Engineering Protocol
- When Short Communication Is Actually Better
- Conclusion: Communication Is a Core Engineering Skill
Why technically intelligent people struggle to build things together
A project doesn't necessarily fail because its developers cannot write good code. Sometimes, it fails because they cannot communicate what code needs to be written in the first place.
The technology industry extensively discusses technical debt, system design, scalability, automation, performance optimization and developer productivity. Yet one of the most fundamental problems receives surprisingly little attention: communication debt.
You can learn multiple programming languages, understand distributed systems, design sophisticated architectures and still be extremely difficult to collaborate with.
Technical intelligence and communication intelligence are two entirely different capabilities.
The ability to translate thoughts into meaningful, actionable information is an underrated engineering skill.
1. Making Statements and Calling Them Suggestions
One of the most common communication problems is that people make definitive statements and later claim they were merely making suggestions.
Consider the following examples:
| Statement | Actual suggestion |
|---|---|
| Use PostgreSQL. | Should we consider PostgreSQL for this use case? |
| Build it using React. | Would React simplify our frontend development? |
| Remove this feature. | Do we really need this feature for the MVP? |
| Change the architecture. | Can we explore an alternative architecture? |
| Go solo. | Would it make more sense to start independently? |
| Don't use Python. | Would another language better satisfy our performance requirements? |
The difference is not merely grammatical. It is psychological and operational.
A statement can communicate an instruction, a decision or an expectation. A question invites participation, evaluation and discussion.
Of course, not every suggestion needs to end with a question mark. Saying, “I would recommend PostgreSQL because we need transactional consistency,” is perfectly reasonable.
The actual problem arises when people phrase their opinions as commands and expect others to interpret them as collaborative suggestions.
You cannot reasonably expect someone to recognize an invitation to a discussion when your communication sounds like a finalized decision.
2. Communicating Conclusions Without Reasoning
People frequently communicate the output of their thinking without communicating the thinking itself.
For example:
Go solo.
What does that actually mean?
- Is the other person unreliable?
- Is coordinating with multiple people slowing down development?
- Is the project small enough for one developer?
- Is there a disagreement about ownership?
- Is the suggestion temporary or permanent?
- Is collaboration itself being discouraged?
Two words can create six different interpretations.
A better way to communicate the same idea would be:
You shouldn't indefinitely wait for someone else to build something with you. Other people have different priorities, schedules and levels of commitment. Start building independently, validate your idea and collaborate when you find someone whose goals align with yours.
Now the recipient understands the underlying principle.
The advice isn't necessarily about working alone. It is about avoiding unnecessary dependencies on other people's availability.
More examples:
| Conclusion only | Conclusion with reasoning |
|---|---|
| Don't build an app. | Validate demand through a website before investing in mobile development. |
| Learn backend development. | Backend knowledge will help you build products without depending entirely on another developer. |
| Don't hire developers. | At this stage, hiring could increase expenses before we establish product-market fit. |
| Stop adding features. | Additional features are delaying the launch without validating our core assumption. |
| Use open-source software. | It may reduce vendor lock-in and give us greater control over customization. |
A conclusion tells someone what to think or do.
Reasoning gives them the information required to make their own decision.
3. Criticizing Something Without Explaining Why It Is Bad
“This is bad.”
“This makes no sense.”
“This won't work.”
“This is a terrible idea.”
These statements communicate disapproval but provide almost no actionable information.
What exactly is bad?
Is it expensive? Slow? Insecure? Difficult to maintain? Unnecessary? Technically infeasible? Commercially unviable?
Consider a code review.
Poor communication:
This function is badly written.
Effective communication:
This function handles database operations, input validation and response generation simultaneously. Separating these responsibilities would make it easier to test and maintain.
Consider an architecture discussion.
Poor communication:
Microservices are a bad idea.
Effective communication:
We currently have three developers and limited traffic. Microservices would introduce deployment, networking and observability overhead before we have a demonstrated need for independent scaling.
Consider a startup discussion.
Poor communication:
Nobody will use this product.
Effective communication:
I'm concerned that the product doesn't solve a sufficiently painful problem. Potential customers already have free alternatives, and we haven't identified a compelling reason for them to switch.
Criticism should identify a problem, explain its consequences and, whenever possible, propose an alternative.
Otherwise, it is merely an expression of dissatisfaction disguised as feedback.
4. Expecting People to Reverse-Engineer Your Thoughts
Your brain has access to your experiences, assumptions, intentions and previous observations.
Your teammates do not.
When you communicate an incomplete thought, the recipient must reconstruct the missing context.
For example:
We should do what that other company is doing.
Which company? Which feature? Which business model? Which implementation? Why?
Or:
Make the dashboard better.
Better in terms of what? Loading speed? Accessibility? Visual appearance? Information density? Navigation?
Or:
Optimize the backend.
Should we optimize memory consumption, database queries, response times, throughput or infrastructure costs?
Ambiguity transfers the cognitive workload from the speaker to the listener.
Instead of spending time solving engineering problems, developers spend time interpreting incomplete instructions.
An API that returns incomplete information is considered poorly designed. Human communication shouldn't operate under a completely different standard.
5. Confusing Requirements With Preferences
Not everything someone wants is a requirement.
Some things are preferences. Others are suggestions, assumptions or optional improvements.
Confusing these categories creates unnecessary work.
| Statement | Actual category |
|---|---|
| User passwords must be securely hashed. | Security requirement |
| I think dark mode looks better. | Personal preference |
| We could use Redis for caching. | Technical suggestion |
| We expect 10,000 users next month. | Assumption or forecast |
| The product must launch by Friday. | Deadline or constraint |
| Animations would be nice. | Optional improvement |
Imagine a designer saying:
The button must be blue.
Is there a branding requirement? An accessibility consideration? A design-system constraint? Or does the designer simply prefer blue?
If it is a preference, communicate it as a preference.
Treating every opinion as a requirement creates unnecessary rigidity and makes collaboration exhausting.
6. Asking Poorly Framed Questions
Asking questions is not enough. The quality of the question determines the usefulness of the answer.
| Poor question | Better question |
|---|---|
| Is Python good? | Is Python suitable for a CPU-intensive real-time application? |
| Which database is best? | Which database fits our transactional workload and expected traffic? |
| Can we build this? | Can two developers build an MVP within four weeks? |
| Is this expensive? | What would the monthly infrastructure cost be at 10,000 active users? |
| Why isn't it working? | Why does authentication succeed locally but return HTTP 401 in production? |
| Should I learn AI? | Which AI engineering skills would help me automate business workflows? |
A vague question usually produces a vague answer.
A well-framed question establishes context, constraints and the desired outcome.
Asking good questions is itself a technical skill.
7. Reporting Problems Without Providing Information
Developers regularly encounter messages like:
The website isn't working.
This is practically useless as a bug report.
A developer now has to ask:
- Which page?
- Which browser?
- What were you trying to do?
- What happened instead?
- Is the issue reproducible?
- Is it happening locally or in production?
- Are there any error messages?
Compare that with:
On Chrome, submitting the login form with valid credentials returns an HTTP 500 error. The issue started after the latest deployment and is reproducible on the production environment.
The second message immediately narrows the investigation.
The same principle applies to development teams.
| Poor bug report | Useful bug report |
|---|---|
| API is broken. | POST /orders returns HTTP 500 when the cart contains multiple items. |
| Database is slow. | The customer search query takes eight seconds on a table containing one million records. |
| Login doesn't work. | Google OAuth redirects successfully but fails to create a user session. |
| Deployment failed. | The Docker build fails while installing dependencies because of a version conflict. |
| UI is broken. | The navigation menu overlaps the content on screens narrower than 400 pixels. |
Good communication reduces debugging time before debugging even begins.
8. Disagreeing Without Identifying the Actual Disagreement
Two developers might spend an hour arguing about which technology is better when they are actually optimizing for entirely different objectives.
Developer A prefers Python because of development speed.
Developer B prefers Rust because of runtime performance and memory efficiency.
Neither is necessarily wrong.
The real disagreement is about priorities.
Should the team optimize for:
- Development speed?
- Runtime performance?
- Hiring availability?
- Infrastructure costs?
- Maintainability?
- Memory efficiency?
- Time to market?
Until those priorities are established, arguing about programming languages is premature.
Similarly, one founder might want to launch quickly, while another wants to perfect the product.
The disagreement may not be about product quality. It may be about risk tolerance and the value of early customer feedback.
Productive disagreements begin by identifying the underlying objective.
9. Mistaking Confidence for Competence
People sometimes express opinions with absolute certainty because they believe confidence makes them sound knowledgeable.
MongoDB is terrible.
Nobody uses Java anymore.
Every startup needs AI.
Kubernetes is mandatory.
Open-source software is always better.
This business will definitely succeed.
These statements ignore context, uncertainty and trade-offs.
A competent communicator should be capable of saying:
- I don't have enough information to conclude that.
- This is my current assumption.
- I haven't tested this approach.
- This solution works under these specific conditions.
- I prefer this option, but it has disadvantages.
- What evidence would change our decision?
Intellectual humility is not weakness. It is a mechanism for preventing expensive mistakes.
Engineering is rarely about finding a universally correct answer. It is about selecting an appropriate solution under particular constraints.
10. Not Communicating Ownership and Responsibility
Consider a team meeting that ends with:
We need to integrate the payment gateway.
Everyone agrees. Everyone leaves.
Three days later, nobody has started working on it.
Why?
Because identifying a task is not the same as assigning responsibility.
A useful decision would establish:
- Task: Integrate the payment gateway.
- Owner: Backend developer.
- Deadline: Friday.
- Dependency: Production API credentials.
- Success criteria: Successful test payments and verified webhook handling.
The phrase “we need to do this” often creates the illusion of collective responsibility while failing to establish individual accountability.
Projects require ownership, not just agreement.
11. Communicating Too Late
Imagine the following conversation.
Monday: A developer discovers an architectural limitation.
Tuesday: They attempt to work around it.
Wednesday: The workaround fails.
Thursday: They try another implementation.
Friday: They inform the team that the feature cannot be completed.
The technical problem existed on Monday. The communication problem continued until Friday.
An early update could have allowed the team to reduce scope, assign another developer, change the implementation or adjust the deadline.
The same applies to unavailable co-founders, delayed approvals, missing credentials, financial limitations and misunderstood requirements.
A blocker communicated early is a manageable problem.
A blocker communicated late can become a project-wide crisis.
12. Failing to Say No Clearly
Some people avoid direct communication because they don't want to appear rude or uncooperative.
They say:
Let's see.
Maybe later.
I'll try.
We should definitely do something together.
I'll get back to you.
These responses can be reasonable when uncertainty genuinely exists. However, repeatedly using them to avoid communicating a lack of interest or commitment wastes other people's time.
Consider a potential co-founder.
Ambiguous response:
Yeah, let's build something together soon.
Clear response:
I'm interested in the idea, but I cannot commit consistent development hours over the next two months. You should start without waiting for me.
The second response may be disappointing, but it allows the other person to make an informed decision.
Someone's ability to plan should not depend on their ability to interpret your hesitation.
Clarity is often more respectful than artificial politeness.
13. Waiting for Someone Instead of Communicating Expectations
Many projects never move beyond the discussion stage because people are waiting for each other.
Someone is waiting for a designer.
Someone is waiting for a backend developer.
Someone is waiting for a co-founder.
Someone is waiting for another meeting.
The underlying problem is often that nobody has established the actual terms of collaboration.
Before starting a project together, discuss the expected time commitment, responsibilities, ownership, financial contributions, deadlines and long-term intentions.
There is a significant difference between:
I'm interested in your project.
And:
I can contribute ten hours every week for the next three months.
Interest is not commitment.
Enthusiasm is not execution.
Verbal agreement is not necessarily accountability.
If somebody tells you to “go solo,” the useful principle behind that advice might be that your ability to execute should not be indefinitely dependent on another person's uncertain commitment.
Start independently when possible. Collaborate deliberately, not out of helplessness.
14. Attacking People Instead of Evaluating Ideas
Technical disagreements become personal when people fail to separate the person from their proposal.
| Personal attack | Constructive disagreement |
|---|---|
| You don't understand system design. | This design doesn't account for concurrent requests. |
| You're overengineering everything. | This implementation introduces complexity that our current requirements don't justify. |
| You're wasting everyone's time. | We have spent two meetings discussing this without establishing decision criteria. |
| You're a bad developer. | This implementation needs additional tests and error handling. |
| You don't understand business. | We haven't established whether customers are willing to pay for this feature. |
The purpose of a technical discussion should be improving the decision, not humiliating the person proposing it.
An environment where people fear being insulted for their ideas eventually becomes an environment where nobody volunteers ideas.
15. Using Technical Jargon to Appear Intelligent
Complex vocabulary does not automatically indicate complex thinking.
Consider this sentence:
We need a horizontally scalable, event-driven, cloud-native distributed ecosystem with autonomous microservices and intelligent orchestration.
What are we actually building?
Perhaps the project is simply an automated email notification system.
Technical terminology is valuable when it communicates precise concepts between people who understand those concepts.
It becomes counterproductive when it conceals uncertainty, unnecessary complexity or a lack of understanding.
A good engineer should be capable of explaining the same concept to different audiences.
To a developer:
We'll use asynchronous background jobs to prevent long-running operations from blocking API requests.
To a founder:
Users won't have to wait on the page while the system processes their requests.
To a customer:
You can continue using the application while your task runs in the background.
Same technology. Different levels of abstraction.
Communication is not about demonstrating how much you know. It is about transferring the relevant knowledge to someone else.
16. Holding Meetings Without Producing Decisions
A team spends 90 minutes discussing a product feature.
Everyone shares opinions. Everyone proposes alternatives. Everyone talks about future possibilities.
The meeting ends.
What was decided?
Nothing.
Unstructured discussions often create the feeling of productivity without producing actual progress.
Every decision-making meeting should ideally answer:
- What problem are we solving?
- What alternatives were considered?
- What decision was made?
- Why was it made?
- Who is responsible?
- What happens next?
A 15-minute discussion that produces a clear decision can be more valuable than a two-hour meeting that produces another meeting.
17. Giving Instructions Without Defining Success
Consider the instruction:
Make the application faster.
A developer spends two days optimizing frontend animations.
Unfortunately, the actual problem was the database response time.
The developer technically followed the instruction but failed to satisfy an expectation that was never communicated.
A better requirement would be:
Reduce the product search API's 95th-percentile response time from 1,500 milliseconds to under 300 milliseconds under our expected workload.
Now the task has a measurable outcome.
More examples:
| Vague instruction | Defined outcome |
|---|---|
| Improve SEO. | Ensure product pages are indexable and have unique metadata. |
| Make the UI responsive. | Support mobile, tablet and desktop layouts without horizontal overflow. |
| Improve security. | Add rate limiting, input validation and appropriate access controls. |
| Automate the process. | Eliminate manual CSV imports through a scheduled data ingestion pipeline. |
| Reduce costs. | Bring monthly infrastructure expenditure below ₹10,000 without compromising agreed service requirements. |
Without success criteria, people can work extremely hard on the wrong problem.
18. Not Documenting Why Decisions Were Made
Six months after launching a product, a new developer asks:
Why are we using this architecture?
Nobody remembers.
The original discussion happened during a meeting. The relevant developer left the company. The reasoning was never documented.
Now the team has to reconstruct the decision from the codebase or repeat the entire architectural discussion.
Good documentation should preserve not only what was decided but also why it was decided.
For example:
Decision: Use a modular monolith rather than microservices.
Reason: Small engineering team, uncertain product requirements and limited operational capacity.
Trade-off: Individual modules cannot be deployed independently.
Reconsider when: Independent deployment or scaling becomes a demonstrated business requirement.
This is institutional memory.
Without it, every new team member risks inheriting decisions without understanding their context.
19. Confusing Communication Skills With Speaking Fluent English
Communication skills are not synonymous with English fluency, vocabulary, accents, public speaking ability or grammatical perfection.
Someone can speak sophisticated English and communicate very little meaningful information.
Someone else can speak simple, imperfect English and communicate exceptionally well.
Consider:
Database slow because every request fetching all rows. Add pagination and index. Should fix most of problem.
This is grammatically imperfect but technically useful.
Compare it with:
I strongly believe that our existing infrastructure requires substantial optimization to facilitate a more streamlined technological experience.
The sentence is fluent but offers almost no actionable information.
Effective communication is about clarity, precision, context, reasoning and mutual understanding.
Language is the medium. Information transfer is the objective.
20. Communication Debt Compounds Like Technical Debt
Technical debt accumulates when engineering shortcuts create future maintenance costs.
Communication debt accumulates when unclear conversations create future coordination costs.
An undocumented decision leads to another meeting.
An ambiguous requirement leads to an incorrect implementation.
An incorrect implementation leads to rework.
Rework delays the release.
The delay creates frustration.
Frustration damages trust.
Reduced trust makes future collaboration more difficult.
Imagine five developers each spending one unnecessary hour per working day resolving misunderstandings.
Over 20 working days, that amounts to 100 developer-hours lost.
At an illustrative engineering cost of ₹1,000 per hour, the team has incurred ₹1,00,000 in avoidable coordination costs in a single month.
No server crashed. No infrastructure failed. No programming language was responsible.
The team simply failed to exchange information effectively.
21. Treat Communication Like an Engineering Protocol
Software systems rely on well-defined communication protocols.
An API typically establishes expected inputs, outputs, error responses and behavior.
Human collaboration can benefit from similar principles.
Before communicating an important idea, ask yourself:
- Context: Why am I bringing this up?
- Problem: What exactly is wrong?
- Reasoning: Why do I believe it is wrong?
- Evidence: What supports my claim?
- Proposal: What should we do instead?
- Trade-offs: What disadvantages does my proposal introduce?
- Question: What feedback or decision do I need?
For example, instead of saying:
Don't use Kubernetes.
Try:
We currently have one application, a small development team and limited traffic. Kubernetes would introduce operational complexity that we don't presently need. I suggest Docker Compose for our initial deployment. We can reconsider orchestration when our scaling requirements justify it. Does anyone see a requirement that Docker Compose cannot satisfy?
This communicates context, reasoning, an alternative, a trade-off and an invitation to disagree.
That is engineering communication.
22. When Short Communication Is Actually Better
Effective communication does not mean writing an essay every time you want to say something.
If the production database is offline, you don't need a philosophical explanation of database availability.
You need to communicate:
Production database is unreachable. Checkout is affected. I'm investigating. Please pause deployments.
The amount of information should be proportional to the complexity, urgency and consequences of the decision.
Simple instructions can be short.
Technical disagreements need reasoning.
High-impact decisions need evidence.
Complex requirements need documentation.
The objective is not maximum communication. It is minimum ambiguity.
Conclusion: Communication Is a Core Engineering Skill
The technology industry needs to stop treating communication as merely a soft skill.
A developer who writes excellent code but cannot communicate technical decisions creates unnecessary dependencies.
A founder who cannot articulate a product vision creates confusion.
A manager who cannot define expectations creates rework.
A teammate who communicates conclusions without reasoning creates avoidable disagreements.
A collaborator who cannot clearly express commitment creates uncertainty.
Good communication does not mean speaking more, sounding sophisticated or being excessively polite.
It means making your thoughts understandable, your reasoning inspectable, your intentions explicit and your expectations actionable.
The purpose of communication is not to prove that you have thought about something. It is to allow others to understand what you have thought about.
We optimize algorithms to reduce computational overhead.
We optimize databases to reduce query latency.
We optimize networks to reduce communication delays.
Why shouldn't we optimize the way humans exchange information?
Your teammates should be debugging code, not decoding your intentions.
Top comments (0)