Human-in-the-Loop Algorithm Design
Decide explicitly what the algorithm owns, what the human owns, and how the handoff works.
- Difficulty
- Advanced
- Time to result
- ~months to results
- Steps
- 6
- Confidence
- 95%
On any ML- or optimization-heavy product, the core product design job is not tuning the model — it is drawing the line between machine decisions and human decisions. Algorithms optimize a given objective but cannot see context, long-term effects, intent, or strategic constraints. Adriel Frederick's approach treats the human-computer interface as a first-order design problem: give people the information for the decisions only they can make, then let the algorithm amplify that intent across millions of individual cases.
Origin
Developed by Adriel Frederick while running Lyft's marketplace and pricing teams, after a sophisticated pricing algorithm proved operationally inflexible; he then recognized the same pattern retroactively in Facebook's feed ranking (ads vs. organic vs. friend-finding mix). Positioned explicitly against the 'techno-utopian' view that you can feed all data to the algorithm, give it an objective, and it will do the right thing.
Core principles
- 01Algorithms don't understand long-term effects, human reactions, or your intent for the product.
- 02Machines are excellent at optimizing a given objective; constraints and strategic choices belong to people.
- 03Software, including ML, is a tool — you decide how much goes into the tool and how much is left to the person.
- 04Operational control is a first-order requirement, not a bolt-on after launch.
- 05The goal is an extension of the operator, not a black box that only needs more data.
How to run it
- 1
Name the objective you'd hand the algorithm
State the naive objective plainly — e.g. 'maximize market share in this region via price.' Write it as if you were about to hand it to an optimizer with no constraints.
Pro tip Use the most literal phrasing possible; the absurdity of the unconstrained version is what exposes the missing judgment.
- 2
Run the objective to its degenerate conclusion
Ask what the algorithm actually does if it optimizes that objective perfectly. Maximize share on price and it drives prices to the floor and you make no money. This reveals the first missing constraint.
Watch out If your objective has no degenerate failure mode you probably haven't stated it honestly.
- 3
Add constraints and re-run the thought experiment
Add the guardrail (e.g. a minimum profit floor) and ask again what happens — including what happens when a competitor optimizes the mirror-image objective. Often both sides hit their constraints and the game stalls, proving that a strategic choice (where do we want to win) exists that no algorithm can make.
Pro tip Simulate the adversary's identical strategy; most objectives break the moment the other side plays the same game.
- 4
Classify each decision as machine or human
Split the decision surface. Machine: high-frequency, per-user, well-specified optimization. Human: context the system cannot observe (snowstorms, fuel prices, new taxes, competitor moves), strategic tradeoffs, and long-horizon intent.
Pro tip The tell for a human decision is 'the algorithm has zero visibility into this' — seasonality, weather, regulation, competitor moves.
Watch out Do not assume the ops decision is temporary scaffolding you'll automate later; treat it as permanent product surface.
- 5
Build the operator's tool as a real product
Design the interface with the same rigor as a consumer surface: give operators the information they need (how is my market doing, how long to pickup, how do I compare to the competition, what are my goals) and the levers to act without creating downstream damage.
Pro tip Ask 'what information does this person need for the decision only they can make?' — not 'what dashboard can we ship?'
Watch out Levers without guardrails let one operator wreck the marketplace; execution tools must prevent trouble, not just enable action.
- 6
Let the algorithm amplify the human's intent
Once the human sets the constraint or strategic choice, the algorithm applies it across hundreds of thousands or millions of individual decisions, using all the local context it can learn. The human decides; the machine scales the decision.
In the wild
Lyft operated in roughly 300 US cities with different pricing in each. A Chicago snowstorm requires raising driver pay to get supply on the road, but every snowstorm is different and the algorithm has no visibility into weather, fuel prices, new taxes, or competitor moves. Rather than trying to model all of it, Frederick's team put a person in the loop: give the local operator the market picture and the tools to adjust, then let the algorithm apply that intent across every ride.
→ Algorithms still handled the bulk of the responses, but the human judgment call supplied the context the model could never observe, producing a more precise response than pure automation.
Facebook could have fed the angry emoji reaction into the ranking algorithm as a high-signal engagement event. The naive optimizer would surface more anger-provoking content because it engages. Leadership instead made an explicit human judgment call to exclude it from the algorithm entirely.
→ A strategic constraint the algorithm could never have derived from the data was imposed by a person — the canonical case of humans owning intent and machines owning optimization.
Common mistakes
Believing there's an algorithmic solution to everything
The techno-utopian position — feed all data to the algorithm, give it an objective, and it will do the right thing — fails because the model has no grasp of long-term effects, of how people will react, or of what you intended the product to be.
Treating operational control as an afterthought
Lyft's team got caught up in algorithmic complexity and 'secret sauce' and never captured operational flexibility as a requirement. The result was a system that took months to change prices in and eventually had to be rebuilt from scratch.
Building the human interface as a black box with a data readout
Giving operators more data about an opaque system doesn't help. The interface must be an extension of the operator's own judgment, with real levers, not a window into a machine they cannot steer.
Is it for you?
Best for
PMs and product leaders on ML-heavy, marketplace, pricing, ranking, or operations-research products where an ops team must steer the system in real time.
Not ideal for
Simple deterministic products with no optimization layer, or early-stage products where no algorithm exists yet to draw a boundary against.
From the transcript
“algorithms don't understand a long-term effects often nor do they understand how people might respond to it nor do they understand your intent for the…”
“it's more about giving people the information that they can use for decisions that they alone are good at and giving machines the power to…”
“learning is going to be amazing at optimizing for a given objective but it's not going to understand the constraints or strategic choices I need…”
“there is a snowstorm and you need to change the way let's say you need to update pricing so that it handles the increases in…”
From the episode
Humanizing product development
Adriel Frederick (Reddit, Lyft, Facebook)