DEV Community: Micky C

The Five Conversations Every Programmer Should Master — And Why AI Can't Do Them

Micky C — Fri, 15 May 2026 15:50:14 +0000

Code is 20% of the Job

Most programmers spend about 20% of their time writing code. The other 80% is something else entirely:

Clarifying requirements in planning meetings
Explaining technical decisions to stakeholders
Negotiating scope and trade-offs with product managers
Giving feedback to colleagues

This is not a soft-skills pitch. This is about the conversations that actually determine whether your code ships, whether your features work, and whether your career advances.

AI can write code. It cannot negotiate a deadline.

Conversation 1: Requirements Clarification

The most expensive bug I've ever encountered wasn't a logic error. It was a feature that did exactly what the ticket said, but not what the stakeholder actually needed. It took three weeks to build, two more weeks to realize the mistake, and another week to fix.

The root cause was a requirements conversation that nobody had.

Requirements clarification is a skill. It involves asking questions that surface hidden assumptions, probing the "why" behind stated constraints, and getting specific about edge cases. Senior developers do this naturally. Junior developers often think requirements are just things written in tickets.

AI does not understand requirements. It does not know your company's context. It cannot ask the question that would have prevented three weeks of wasted work.

The developers who get things right the first time are the ones who had the right conversations before writing a line of code.

Conversation 2: Technical Trade-off Communication

Every architectural decision is a trade-off. You're choosing speed of development over flexibility, or simplicity over scalability. The developers who advance fastest are the ones who can articulate these trade-offs clearly — to managers, to other engineers, to stakeholders.

This matters because technical decisions often have business consequences that aren't immediately obvious. A "clean" architecture might take twice as long to build. A "quick" solution might create technical debt that slows down the team for months.

The conversation isn't just about the technical merits. It's about mapping technical reality to business constraints, and doing it in language that non-technical stakeholders can understand and act on.

AI can explain technical concepts. It cannot weigh trade-offs in the context of your specific business, team, and timeline.

Conversation 3: Scope Negotiation

"Why can't we have it all?"

Because scope is a negotiation. Features take time. Time has a cost. Resources are finite. Every "yes" to a feature is implicitly a "no" to something else — usually something implicit.

The developers who are trusted partners in product decisions are the ones who can have honest scope conversations without destroying relationships. They can say "yes, we can do that, but here's what it costs" and help find creative solutions that satisfy the underlying need without killing the timeline.

This is a conversation about priorities, about trust, about understanding what actually matters to the business. AI has no skin in the game.

Conversation 4: Feedback Delivery

The hardest feedback to give is honest feedback that might sting. The hardest feedback to receive is feedback that challenges your assumptions. The developers who get better fastest are the ones who can do both.

Giving feedback well requires reading the other person's emotional state, understanding their context, choosing the right moment, and framing the message so it lands rather than bounces off.

This is not a technical skill. It's not something you can learn from documentation. It's something you learn from actually doing it — and from getting it wrong, and trying again.

AI cannot give feedback that changes behavior. It can generate words that sound like feedback.

Conversation 5: Mentoring Handoffs

The most valuable developers don't just write code. They grow the team around them. This means mentoring junior developers through the moments that define how they think about software.

The handoff conversation is when you explain why a decision was made a certain way, what you considered and rejected, and what the junior developer should watch out for. Done well, this is worth more than any blog post or tutorial.

It's not about the code. It's about the judgment behind the code. And judgment transfer requires human connection.

Why AI Can't Do These

AI processes language. It can generate responses that sound like these conversations. It can even simulate the structure of a good negotiation.

What it cannot do is:

Understand the specific humans involved and what they care about
Read the room before deciding how to frame a difficult conversation
Make the judgment call about which battle to fight and which to let go
Build the trust that makes honest conversations possible

These conversations require you to be present. AI is never present.

Part of the AI-Proof Programmer series.

The AI-Resistant Programmer: Why Soft Skills Matter More Than Code

Micky C — Fri, 15 May 2026 15:44:37 +0000

The World Changed Quietly

In 2023, something strange started happening in programming communities. People who had spent years building their careers around technical excellence began noticing something unexpected: the developers getting promoted weren't always the ones who wrote the best code.

They were the ones who could explain that code to a product manager in plain English. The ones who knew which meetings to show up to and which to skip. The ones who could tell a junior developer why something was done a certain way — and make it click.

This isn't a story about AI replacing programmers. It's a story about what AI makes more valuable.

The Skills That Actually Matter

Ask any senior developer what separates great programmers from competent ones, and you'll rarely hear "writes cleaner code" as the first answer. You'll hear things like:

"They understand the business context"
"They know when to push back on requirements"
"They make everyone around them more effective"
"They can debug by talking to the system, not just staring at logs"

These are soft skills. And soft skills are exactly what AI can't replicate.

Why Soft Skills Are AI-Resistant

AI is trained on patterns. It excels at tasks with clear inputs and outputs, where the "right" answer is verifiable. Soft skills are the opposite — they're ambiguous by nature, context-dependent, and require reading people.

When an AI can reliably tell you that your product manager's actual concern behind that feature request is security theater, not user experience — come back and tell me about AI-resistant skills.

Soft skills matter more in an AI-powered world because:

Communication is coordination. Every hour a developer spends in meetings is an hour they're reducing coordination costs. High coordination costs destroy software organizations. Being the person who makes meetings productive is irreplaceable.

Judgment is scarce. AI can generate options. It can't tell you which option aligns with a three-year-old company's actual strategy when the CEO just changed direction last week. That judgment requires context, relationships, and trust.

Trust is non-negotiable. Senior developers get access to systems, data, and decisions that junior ones don't. Trust is built through relationships, not capability. You can't AI-generate trust.

The Quiet Revolution in What Companies Value

The developers who are thriving right now aren't necessarily the ones with the most LeetCode points or the deepest systems knowledge. They're the ones who can:

Translate between business language and technical constraints
Identify which technical debt actually matters (hint: not all of it)
Mentor juniors without making them feel stupid
Push back on deadlines without killing the relationship
Know when "good enough" is actually good enough

These skills were always important. But in a world where AI handles more and more of the technical work, the differentiator is everything AI can't do.

What This Means For Your Career

The programmers who should be worried aren't the ones who write good code. They're the ones whose only value is writing good code. If your entire value proposition is technical execution, you'll be fine — for now. But "for now" is a dangerous place to build a career.

The people who will thrive are the ones who use AI as a productivity multiplier for their soft skills. Imagine being 10x more effective at the things AI can't do. That's the opportunity.

The AI-Resistant Programmer isn't anti-AI. They're the developer who uses AI to handle everything except the part that actually matters.

Part of the AI-Proof Programmer series.

Test 1

Micky C — Mon, 11 May 2026 19:59:13 +0000

Body here