How to Brief a Developer
Brief the problem and the outcome you need, not the solution you’ve imagined — that one shift is the difference between getting what you meant and getting what you literally said. A good developer can solve a problem far better than you can specify a solution, but only if you tell them the problem. Brief them a half-formed solution instead, and they’ll build exactly that, and you’ll get exactly what you asked for, which is rarely what you wanted.
That’s the answer. Here’s why describing the outcome beats describing the feature, what a brief actually needs to contain, and why the brief is the cheapest place to make a build go right.
Tell them the problem, not your guess at the solution
The instinct, when you want software, is to describe the thing you picture: a button here, a screen that does this, a list that shows that. You translate your problem into an imagined interface and hand over the interface. This feels helpful and it’s the single most common way briefs go wrong.
The reason it fails is that your imagined solution is a guess, made by someone who doesn’t build software, about how to solve a problem you understand far better than the solution you’ve sketched. When you hand over the sketch instead of the problem, you throw away the developer’s biggest contribution — their ability to find a better solution than the one you pictured. They can’t tell you “there’s a simpler way to do that” because you didn’t tell them what that was for; you just told them to build the button. So they build the button. It works, technically, and it solves your problem worse than it needed to, because the person best placed to find the good solution was never shown the problem.
Brief the outcome instead. Not “put a button here that exports a spreadsheet” but “at month-end I need to get these figures to my accountant, and right now I copy them by hand and it takes an afternoon and I make mistakes.” Now the developer knows what you’re actually trying to achieve, and they might build the button, or they might do something better you’d never have thought of — send the figures automatically, skip the spreadsheet, remove the afternoon entirely. You described the destination and let the person who knows the roads choose the route. That’s the whole skill of briefing.
What a brief actually needs
A brief that works contains a few specific things, and they’re not the things people usually put in.
The problem, in plain terms — what’s wrong now, what it costs you, why it matters. This is the part most briefs skip and the part that matters most. The developer needs to understand the pain before they can solve it well.
The outcome you need — what does success look like, concretely. Not the feature, the result. “I need to know which customers haven’t paid, without going through the spreadsheet by hand.” The developer turns outcomes into features; that’s their job, not yours.
The real-world context — who uses this, when, on what, how often, what happens around it. Software lives inside a workflow, and the workflow is invisible to the developer unless you describe it. The thing that breaks builds is the context nobody mentioned: the user is on a phone, the data arrives in a weird format, this happens five hundred times a day, there’s a regulation involved. Surface that up front.
The boundaries — what’s explicitly not needed, what’s out of scope, what can wait. Telling a developer what not to build is as valuable as telling them what to build, because it stops them solving for cases that don’t exist and gold-plating things you don’t care about.
What you’re unsure about — say plainly which parts you haven’t figured out. A good developer will help you think through the uncertain parts if you flag them, and will quietly build the wrong assumption if you don’t.
Notice what’s not on the list: implementation detail, technology choices, how it should work under the hood. That’s theirs. You own the problem and the outcome; they own the solution. A brief that crosses that line and starts dictating the build is a brief that’s taken away the developer’s job and kept the part you’re worse at.
The brief is the cheapest fix there is
Here’s why this is worth real effort. The brief is the point in a build where changing your mind costs nothing — it’s words, you can rewrite them in an afternoon. Every stage after that, changing direction costs more: a sketch is cheap to redo, a built feature is expensive to redo, a shipped system wired into your operation is painful to redo. Almost all the cost of getting a build wrong is the cost of discovering, late, that the brief was wrong.
So the brief is where you spend your thinking, not your building. An hour getting the brief right — actually articulating the problem, the outcome, the context, the boundaries — routinely saves weeks of building the wrong thing and rebuilding it. Most failed builds I’ve seen didn’t fail in the code. They failed at the brief, where a vague problem and an imagined solution got handed over, and the build faithfully executed the misunderstanding. The code was fine. The instruction was wrong, and nobody caught it until it was expensive.
This is also the cheapest place to apply MVP thinking. A brief that says “here’s the whole vision, build all of it” gets you a build of all of it. A brief that says “here’s the core problem, solve that first, here’s what waits” gets you a lean first version that ships and earns. You scope in the brief, in words, before a line of code commits you to anything.
When a tight brief isn’t the move
I’m not dogmatic about briefing everything up front, and there’s a case where over-specifying hurts.
When you genuinely don’t know what you need yet — when the problem itself is still fuzzy and you’re exploring — don’t force a detailed brief. Trying to nail down a precise spec for something you don’t understand yet produces a confident brief for the wrong thing, which is worse than an honest “I’m not sure, let’s prototype and find out.” In that case, brief the uncertainty itself: here’s roughly the area, here’s what I’m trying to learn, let’s build something small and rough to think with. The tight brief is for when you know the problem. When you don’t, the honest brief is a loose one that says so.
A pattern I see
The recurring one: a founder hands a developer a detailed spec — screens drawn, buttons placed, every feature described — feeling proud of how thorough it is. The developer builds exactly it. It ships. And it’s awkward to use, because the founder specified an interface they imagined rather than the problem they had, and the developer, given a precise solution, never got to point out that the underlying need could’ve been met far more simply.
When I see those builds, the fix is almost always to go back to the problem the spec was trying to solve — which usually takes one conversation to extract, because it was never written down — and find that the real need was simpler than the elaborate solution. The thorough spec wasn’t thorough about the right thing. It was detailed about the how and silent about the why, and the why is the only part the developer couldn’t supply themselves.
Who this isn’t for
If you have an in-house technical lead who already owns translating business needs into specs, you don’t need to brief developers directly — that’s their job, and inserting yourself into it just adds a layer. This is for founders and owners working with developers or an agency without a technical person of their own in between.
The call, in one line
Brief the problem and the outcome, name the context and the boundaries, and leave the solution to the developer — because the brief is the cheapest place to get the build right.
This is one of my playbooks. It’s the counterpart to how to evaluate a software quote — a clear brief is what makes an honest quote possible — and it runs on the same logic as how to scope an MVP, since the brief is where the MVP cut actually gets made. If the next step is choosing who to brief, how to evaluate a developer covers picking the right person.
If you’ve got a build coming and want help turning what’s in your head into a brief that gets you what you meant, talk to me — getting the brief right is usually a single focused conversation that saves the whole project. And if what you’re briefing needs a full team to build and run, that’s what my agency, Digital Royalty, is for.