Back to Writings Good Sign with a backdrop of an office building

No Amount of AI Fixes a Broken Translation Layer

Published ~5 min read

I think it’s important to start this article with the notion that I am not a Project Manager and I know for a fact that being a Project Manager is stressful. With that said, let’s begin.

If you have been writing code for more than a decade or so, you have probably noticed a quiet shift in the software ecosystem. Or, at least I have. If I think back about ten years ago, my tasks or features were governed by the “traditional” Project Manager. They were responsible for translating business requirements and acted as a conduit between the people writing the code and the stakeholders paying for it. They also created the feature, bug, etc. in whatever tracking software (GitHub, Azure DevOps, Jira, etc.) we were using.

Slowly the interactions with Project Managers started to drop. So slowly, in fact, that I didn’t even notice initially. Today, as an R&D Tech Lead Engineer steering multiple teams through a multitude of projects, I rarely talk to Project Managers, except when something goes awry. Maybe it was the rise of Agile. But that brought in Scrum Masters and Product Owners. Maybe it was the way DevOps and CI/CD automated away the need for human release orchestration.

But while PMs have migrated in the organization stack, a massive, industry-wide friction point remains, I believe: the Project Manager as a customer proxy.

Phone Tag and the “Yes” Promise

Having a non-technical PM act as the sole lifeline between the customer and engineering team is often a recipe for broken requirements and fabricated timelines.

When I have been lucky enough to be invited to these meetings, a customer will describe a business problem to a PM. The PM often translates that into a proposed solution before even consulting with the engineering team. Because they don’t have a deep look into architectural context, critical nuances are lost. The engineering team then builds to the PM’s spec, but the final product sometimes fails the customer’s actual need.

Another instance is the “Yes” Promise. Customer-facing PMs face immense pressure to appease demanding clients. And that is a difficult job, especially if they have multiple clients. In a meeting, they might agree to a new feature, a tightened deadline or a massive architectural change without first assessing the engineering team’s capacity. And what could make it worse is if multiple PMs do this at the same time. By the time it makes it to the developer, the date is locked in and only three things can happen: the client is let down because the deadline is missed, the sprint is derailed or the developer works overtime to complete it.

But What About AI?

Generative AI is here to save the day, right? In my opinion, it actually makes the problem worse. There are two dangerous misconceptions that get introduced.

  1. Instant Velocity is a Myth: I’ve lost count of how many times I’ve heard in the real world that developers have AI, so they should be coding at the speed of light. What is often not understood is that without proper context it doesn’t do everything. Of course, it does let a skilled developer produce more code if the requirements are right and the time was taken to give it context on the architecture, deployment, systems, etc.
  2. AI-Generated “Specs”: A PM, or pretty much anyone in the organization, can ask an LLM to generate a requirements document and produce a multitude of pages of confident-sounding requirements in a couple of minutes. To the author, it looks complete. Yet, it could be misunderstanding the architecture (recommending Postgres when MSSQL is actually being used), security constraints, migrations, etc. It’s fundamentally fluff.

From the Bench: The Pushback

I’ve been thinking about this a lot, as you can probably tell. And it’s not from a negative light. More of a curious one. Here are some ways I think it can be handled.

  1. Demand the Problem, Not the Solution: Often when a developer receives a requirement, it’s usually technical and could come from a PM or even a Tech Lead. A simple ask for what the customer was requesting will provide a high-level view on complications and the simple reason of “Why”.
  2. Contracts: Vague requirements lead to technical debt. The key is to move the conversation from emails and messages (MSFT Teams, Slack, etc.) towards machine-readable contracts. I prefer Markdown files, but just about anything is better than nothing. Having a spec-driven development lifecycle with an AI that understands how your system works, languages that you use for different tasks and design system understanding goes a long way.
  3. Scope vs Cost vs Time: This often reminds me of signs you see in a mechanic shop. Good and Cheap won’t be Fast. Fast and Good won’t be Cheap. Cheap and Fast won’t be Good. You can only get two. If the PM locked in the Time and the Cost, the Scope must be flexible. I, personally, don’t say “No, we can’t do that by next Friday.” I would say something like, “We can hit next Friday, but we are going to cut these three features to do it safely, or we keep the features and the timeline has to change.” It’s a tradeoff either way you phrase it.

Project Managers provide massive value when they align with customer requests and work closely with engineers. The distance between the customer’s needs and the people executing solutions needs to be as short as possible. No amount of AI can fix a broken translation layer.