The Developer Is Not an Order Taker
Just tell me what you want, and I'll build it" sounds humble, but it treats a request as a finished specification. The better move is to ask what problem the request is meant to solve, respect what the business knows, disagree with reasons when I see a better path, and own the result. That judgment is the part of the work AI doesn't replace.
Leadership Philosophy Series — 20 articles
- The Power of Lifelong Learning
- AI and Critical Thinking in Software Development
- Sidetracked by Sizzle: Staying Focused on True Value
- The Managed Transition Model: Leadership Promotion as Power Exchange
- When the Pressure is On - Late Sprint Hotfix Governance
- Accountability and Authority: Walking the Tightrope
- Turtling: When a Team Stops Looking for the Door
- Every Arm Is Still Searching: The Octopus Model of Agency
- The Dependencies I Never Upgraded
- The Beaver Builds a Pond
- The Shark Stops Evolving When It's Done
- The Engineering Zoo: When the Dashboard Gets Better but the Zoo Does Not
- Tactical Excellence, Strategic Truth: Who Checks Whom
- A Journeyman's Guide to Three-Week Sprints
- Momentum Is Not Propulsion
- The Last Generation of Masters?
- Confident Humility: Earning and Keeping Client Trust
- Solve the Problem, and Get Out of the Way
- Knowing When to Let My Creation Die
- The Developer Is Not an Order Taker
Filed under Leadership and systems thinking
Topic cluster
Project Leadership and DeliveryProject Mechanics, leadership judgment, delivery accountability, and team operating models.
"Just Tell Me What You Want"
"Just tell me what you want, and I'll build it."
I've heard developers say that for my entire career, and it remains one of my biggest pet peeves. It sounds accommodating. It even sounds humble — the developer isn't presuming to tell the business how to run itself. But as a way of working, it has produced some of the worst software I've seen, and in the age of AI it's quickly becoming the easiest part of this profession to replace.
I want to be careful about what I'm criticizing, because there's a version of this argument that goes somewhere unfair. I'm not talking about developers who love implementation. Some of the best people I've worked with care deeply about craft: clean code, careful tests, a query tuned until it's exactly right. That work is valuable, and solving problems well depends on it. What bothers me is unquestioning implementation — the habit of treating a request as a finished specification and switching off curiosity the moment the instructions arrive.
A request is the beginning of a conversation, not the end of one.
I made the short version of this argument in Solve the Problem, and Get Out of the Way, where I called most requests a first draft of the problem. This is the longer version.
The Report Nobody Needed
Picture a manager asking for a new report. An order taker asks which columns, which filters, and what time of day it should land in the inbox. Fair questions, every one of them, but they skip the important one: what decision is this report supposed to help someone make?
Once that question is on the table, the answer can go several directions. Maybe a report really is the right thing. Maybe what the manager needs is an alert when an exception happens, rather than a list to scan every morning looking for the one line that matters. Maybe the information already exists, and the real problem is that nobody can find it. The original request was a reasonable guess at a fix, made by someone who knows the business and doesn't think in software.
Or picture someone asking for another approval step in a workflow. Easy enough to build. But what risk is the approval supposed to control? Who's accountable when something gets approved that shouldn't have been? What happens when the approver is on vacation for two weeks? Could a simple rule keep the risky case from happening at all, so nobody has to approve anything?
None of those questions is meant to turn a simple request into a project. Sometimes asking them confirms the original request was exactly right, and I build it with more confidence than I would have otherwise. Asking good questions isn't a license for endless discovery, either. The point is to avoid spending weeks building something that doesn't improve anything.
Two Kinds of Knowing
There's an opposite failure, and I've seen plenty of it too: the developer who dismisses business people because they don't speak the technical language, and who treats every request as further proof that users don't know what they want.
That's just as unhelpful, and a good deal less pleasant to work with. The business knows its customers, its obligations, its constraints and the hundred small reasons a process works the way it does — reasons that are rarely written down anywhere. I bring a different kind of knowledge: what software can reasonably do, what a change will cost, where it's likely to fail, and how to make it dependable. Good solutions come from putting those two kinds of knowing in the same conversation and letting each one correct the other.
So the stance I try to hold is easy to describe and harder to practice. Help me understand why this matters. Listen to the answer, all of it. Then, if I see a better path, say so plainly and explain why.
Sometimes that means disagreeing. "I can build that, but I don't think it will do what you're hoping" is an uncomfortable sentence to say to someone who's paying for the work. It's also one of the most useful things a developer can offer, as long as the disagreement comes with reasons and a genuine willingness to be wrong. When the business has information I don't, I want to change my mind quickly and without a fuss.
The Myth of the Safe Choice
Order-taking can look like the safe choice. If I build exactly what was asked for, nobody can blame me when it doesn't help.
That safety is an illusion, and the cost always lands somewhere. The business pays for software that doesn't solve its problem. The users live with a workaround that quietly becomes permanent. The next developer inherits a system shaped around a request instead of a need, and spends months trying to work out why it's built the way it is. I may have been blameless, but I wasn't useful — and on a long enough timeline, people notice the difference.
Some of the best work I've ever done started outside the original request entirely. I was brought in for one project, talked with the people around it about their work, and found a different problem that mattered more to them than the one I'd been hired for. An order taker would never have found it, for the simple reason that nobody had written it down as an order.
Why AI Changes the Math
For a long time a developer could build a perfectly good career on translating clear requirements into working code. That skill still matters. But AI is changing how scarce it is. When a task is specified clearly, modern tools can produce a plausible implementation remarkably fast, and they get noticeably better every few months.
I don't think questioning assumptions is a uniquely human ability. AI can help analyze a request, propose alternatives and point out gaps, and I use it that way. What doesn't go away is accountability. Someone has to decide whether the proposed solution makes sense in this particular business, whether the evidence that it works is credible, and whether the result actually helped anyone. A tool can contribute to those judgments. It can't own them.
A developer whose whole offer is "give me instructions and I'll implement them" has chosen to compete on exactly the dimension AI is improving fastest. That's a risky place to stand. The work that holds its value is the work before and after the code — understanding intent, weighing trade-offs, and checking whether the outcome matches the need. I'd much rather let AI lower the cost of implementation and spend more of my own attention there.
Back to the Order
I owe the business more than obedience: professional curiosity, technical judgment, honesty about what I know and what I don't, and a willingness to raise an uncomfortable question respectfully and early, while changing course is still cheap.
The result might still be the report, the approval step or the application someone originally asked for. Often it is. But by then it's a considered solution, built by someone who understands why it exists, rather than an instruction carried out by someone who never asked.
So when I hear "just tell me what you want, and I'll build it" — from someone on a team, or occasionally from the less patient corner of my own head — I'd rather swap it for a better opening line: what problem does this need to solve?
Explore More
- Solve the Problem, and Get Out of the Way -- The philosophy this essay comes from
- Sidetracked by Sizzle -- When a request is more exciting than it is useful
- From Features to Outcomes -- Why shipped features aren't the same as results
- AI and Critical Thinking in Software Development -- The judgment that stays with the developer
- The Art of Making Yourself Replaceable -- Doing the job so well it doesn't need you
Related project evidence

Data Analytics Web Project Manager
DAWPM transforms CSV data into interactive visualizations, pivot tables, and detailed analytics. Built with ASP.NET WebForms 4.8 (VB.NET), featuring a modern Webpack build system, Bootstrap 5.3, DataTables 2.3, D3.js/C3.js charting, and PivotTable.js with drag-and-drop analysis.

DevSpark: Constitutional AI Governance Framework
DevSpark is a standalone AI-assisted development framework that extends Specification-Driven Development with constitution-based PR reviews, codebase-wide compliance auditing, adversarial risk analysis, brownfield constitution discovery, and adaptive lifecycle management. DevSpark makes project constitutions valuable throughout the entire development lifecycle — from greenfield planning through continuous constitutional governance.
Used across most of my active repositories, including this site

API Test Spark
A NuGet package that embeds an interactive API test harness into any .NET 10 Minimal API with one line of code. It reads the API's own OpenAPI contract, so there is nothing extra to keep in sync.
Thousands of NuGet downloads
Working through something similar?
If this maps to something you're working on, I'm glad to compare notes. Start with the system and the constraint that matters most.