Author’s note: From “fixing one crash” to “making the app stop crashing,” this article breaks down the 5 changes your workflow has to make before you hand the results over to AI — plus a no-code rollout process you can follow.
Lots of teams now use AI every day to write emails, polish copy, and build slide decks, but they can’t shake the feeling that it’s worth more than that. The problem usually isn’t the model — it’s that what we hand over is too small. What we hand over is a task, not a result. Drawing on recent practical ideas shared by Claude developer Felix Rieseberg, this article walks through the workflow makeover that takes you from “delegating tasks” to “delegating results”.
This isn’t another collection of prompt tricks. No matter how well you write the prompt, if the AI can’t get at the data, can’t touch the environment, and has no external way to verify its work, it’ll just spin in circles inside the little box you drew for it. The thing that has to change first is the workflow itself.
Why it matters: By the end of this article, you’ll know which work is worth “handing the result to AI,” and which 5 foundations you need to shore up before you hand anything over — so the AI can keep running on its own over the long haul.
The Core Difference Between Delegating Tasks to AI and Delegating Outcomes to AI
Felix Rieseberg breaks the “ambition” of working with AI into four dimensions: speed, height, depth, and breadth. Speed is the most mature way to use it, while “delegating outcomes to AI” mostly maps to the height dimension — depth and breadth set the upper limit on how good those outcomes can be.
| Dimension | What it means | Typical approach | Workflow requirements |
|---|---|---|---|
| Speed | Doing the same work in less time | Getting AI to write code and docs faster | Low — your existing process is enough |
| Height | Focusing on the end result rather than the task in front of you | Shifting from “fix this bug” to “stop the app from crashing” | High — you need data channels and a verification environment |
| Depth | Thinking like a top expert in the field | Replacing Markdown tables with databases and statistical models | Medium-high — you need raw data and specialized tools |
| Breadth | Borrowing methods from other fields | Pulling in the methodologies of journalists, editors, and short sellers | Medium — you need multiple sessions or sub-agents |
Why delegating outcomes to AI is first and foremost a workflow problem
When you hand a model a task, what it actually executes is “the approach you currently believe is most likely to achieve the goal.” In other words, the task already contains your judgment — the model is just the executor. To move up a level, you have to ask yourself: what do I actually want to happen next? What bigger goal sits behind the one right in front of me?
The original article gives a very concrete example. The author initially asked Claude to fix individual crash bugs one at a time, then simply put it in charge of “keeping the app stable and crash-free.” But that step isn’t something you can pull off by rewriting a single prompt: he first had to make sure Claude could easily pull crash reports, know which Git commit corresponded to each app version, and have access to Windows, macOS, and Linux machines. Only then could it reproduce issues independently and verify whether a fix actually worked.
That’s the core argument of this piece: delegating outcomes to AI requires that the AI has the inputs, the hands-on capability, and the means to verify — the full loop. Miss any one of those, and outcome delegation degrades back into task delegation, leaving you right where you started: constantly handing it work.
The three-level leap of handing results to AI: a quarterly review example
The original article uses a “somewhat tedious” office task as a demonstration: creating quarterly business review (QBR) slides for a fictional company, Acme. The same task can be graded into three levels, from low to high.
| Level | What you hand to AI | Typical phrasing | What AI needs |
|---|---|---|---|
| L0 Task | Filling numbers into a template | “Turn this data into slides” | A cleaned-up dataset |
| L1 Understanding | Figuring out what happened | “Tell me what changed this quarter, why, and what we should do” | As complete a set of business data as possible |
| L2 Decision | Driving the meeting toward a decision | “Identify the three most urgent decisions, with arguments for and against” | Data plus business context and constraints |
| L3 Mechanism | Redesigning the review itself | “Design a better approach than quarterly slides, prove with historical data that it catches problems earlier, and run it in parallel with the existing process for one quarter” | Historical data, a runtime environment, and controlled validation |
By L3, what you’re handing over is no longer “a set of slides” but the outcome of “letting management spot problems early and allocate money and people to the right places.” The original article offers a handy signal for judging this: if what you’re working on will still need a meeting to discuss afterward, it’s probably worth raising the goal one level higher.
5 Things to Fix in Your Workflow Before You Hand Results to AI
Put the two cases together—the crash triage and the quarterly review from the original article—and you can boil them down to five pieces of infrastructure you need to fix first. The table below lines up both cases side by side so you can map them onto your own business.
| Fix | Crash triage case | Quarterly review case | Self-check question |
|---|---|---|---|
| 1. Raw data channel | Can read crash reports directly | Can access raw business logs and user data | Is AI getting raw material or secondhand summaries? |
| 2. Traceable mapping | Version numbers map to Git commits | Metric definitions map to data sources | Can AI trace from symptom back to cause? |
| 3. An environment it can actually touch | Test machines for the three major operating systems | Can install software, run databases and statistical models | Can AI reproduce and experiment on its own? |
| 4. External judgment | After the fix, it actually stops crashing | Validate predictive power with data the model hasn’t seen | Is the result proven by something outside the AI? |
| 5. Parallel run and exit | Fix is validated in the test environment first | New mechanism runs in parallel with the old process for a quarter | Can you roll back without loss if it fails? |
Improvement 1: Open the Raw Data Channel for Handing Results to AI
The original article repeatedly stresses in its “Depth” section that top professionals start from the most raw materials, not from information that has already been organized and processed. Many “accepted facts” in business are actually rough approximations of reality. If you only give AI a summary table someone else made, it can only reason on top of that approximation.
In practice, you can start by making an “AI-readable data checklist”: logs, tickets, crash reports, read-only database accounts, historical documents, and so on. The original article notes that you can give the model access to the relevant data through MCP connectors or other channels. Plenty of tools already offer this capability, and picking one and using it is far more reliable than repeatedly pasting things in by hand.
Improvement 2: Build a Traceable Mapping from Symptom to Cause
In the crash case, “which Git commit each app version corresponds to” looks like a detail, but it determines whether AI can trace a crash report to a specific code change. Without that mapping, AI can only guess—and if it guesses wrong, you still have to step in manually.
In a business context, that means metric definitions need to be traceable back to their data sources. For example, what time window and which user segment “churn rate” is calculated over must be transparent to AI. The clearer the mapping, the less likely AI is to drift when working at a higher level of abstraction.
Transformation 3: Give the AI a computer it can actually use
The original article puts it plainly: all the earlier approaches share one prerequisite — the model needs access to a computer where it can install software and pull in all sorts of relevant data. When Claude tries to get away with a Markdown table instead of real analysis, you have to insist it use a database and statistical models. After all, “making the model act like an expert” often just swaps in a new vocabulary without changing how the work actually gets done.
For engineering teams, this step means sandbox environments, test machines, and permission isolation. For business teams, it means a workspace where analysis tools can actually run. On permissions, follow the principle of least privilege: start read-only, and only open up write access gradually once you’ve verified things are reliable.
Transformation 4: Insist on external evaluation — don’t let the AI grade its own homework
The original author’s advice is crystal clear: at least as of October 2026, strongly stick with external verification — ideally tools the model can run itself and get immediate feedback from. Test cases, real reproduction results, and held-out validation datasets are all far more reliable than “the model rated itself an 8 out of 10.”
In the deeper version of the quarterly review exercise, the original has Claude build a customer behavior simulation from the logs, find the earliest signal that predicts churn, and then prove with data it has never seen that this signal really does have predictive power. That’s what external evaluation looks like in its standard form: conclusions have to withstand scrutiny from outside the model.
Transformation 5: Design a Parallel Run Period and Exit Conditions
There’s one key move for L3-level delegation: run the new mechanism in parallel with existing processes for a quarter. That’s not just caution — it’s also a form of external evaluation. Whether the new mechanism really catches problems earlier can be measured against the old process running over the same period.
At the same time, you have to be honest about the limits. The original article admits that by 2026, a simple “Claude, go make money” still won’t work for most enterprises. So every outcome delegation should spell out its boundaries, checkpoints, and fallback options, rather than handing everything over all at once.
Quick Start for Handing Outcomes to AI: A No-Code Delegation Process
The process below doesn’t require any programming, and product, operations, analytics, and engineering teams can all apply it directly.
Step 1: Decide whether the work is worth handing the result to AI
Start with three questions: Will this work still need a meeting afterward? Does it have a clear final result, rather than just a creative output? Does it repeat periodically? The original article points out that raising the level of the goal is most useful when you’re pursuing a final result, and it’s less applicable to creative work. If you answer “yes” to two of the three questions, it’s worth a try.
Step 2: Fill out an outcome delegation brief
Instead of writing one long prompt, break the delegation into fixed fields. You can reuse the brief structure below directly.
| Field | What to fill in | Example (crash management) |
|---|---|---|
| Final result | What you actually want to happen | The app stays stable on the three major platforms |
| Goal behind the result | The intent one level up | Reduce user churn caused by crashes |
| Available data | List of source materials and how to access them | Crash reports, version-to-commit mapping |
| Available environment | Machines and tools the AI can operate | Windows, macOS, and Linux test machines |
| External validation | Who or what proves the result is correct | Can reliably reproduce and verify the fix works |
| Boundaries and fallback | Lines that must not be crossed and what to do if it fails | Only modify test branches; merge manually |
| Challenge target | A seemingly unreasonable high standard | Example from the original article: require load time to go from 10 seconds straight to 200 milliseconds |
The “challenge target” field comes from a deeper suggestion in the original article: set a goal that looks unreasonable, and tell the model it’s completely reasonable. If the model says it can’t be done, emphasize again that the problem is solvable and it just needs to keep working. Psychology backs this up too: after reviewing 35 years of goal-setting research, Locke and Latham concluded that specific, challenging goals outperform a vague “do your best.”
Step 3: Rewrite your brief with the “four deep questions”
The original author shared a prompt pattern they use often: before rewriting a task, have the model answer four questions first. You can put it in your own words like this:
I want to make this task deeper, not bigger. Before you start, answer these: 1) What would a top professional in this field do that I haven’t asked for? 2) What are the most primary, raw materials they’d start from? 3) What specific methods and tools would they use? 4) Beyond your judgment and mine, what could prove the result is correct? Then rewrite my brief based on that.
These four questions map to the earlier upgrades: raw data, professional tools, and external judgment. The gaps the model points out are usually exactly what you need to fill in your workflow.
Step 4: Choose how to connect the model
Result-oriented briefs typically run for a long time and across many turns, so the stability of your model access and the cost of switching have a direct impact on rollout. APIYI provides API access to the Claude series and other mainstream models covered in this article, and is compatible with both OpenAI and Anthropic interface formats. Existing SDKs or agent frameworks usually just need base_url and the API key swapped out. For the exact endpoints and parameters, refer to the APIYI docs at docs.apiyi.com.
| Access need | Recommended approach | Notes | Available platforms |
|---|---|---|---|
| Projects that already use the OpenAI SDK | OpenAI-compatible format | Change base_url and the API key |
APIYI apiyi.com, official API |
| Using Claude’s native capabilities | Anthropic-compatible format | Keep the Anthropic message structure | APIYI apiyi.com, official API |
| Multi-model comparison and validation | Switch model names on a unified interface | Compare different models in the same workflow | APIYI apiyi.com |
| Cost estimation | Check the pricing page | Input, output, and cache unit prices are governed by the pricing page | Pricing page: https://docs.apiyi.com/models |
🚀 Getting started tip: Result-oriented briefs usually need to run a closed loop on a small scale first, then scale up gradually. We recommend starting with APIYI apiyi.com, connecting one or two models through a unified interface for comparison testing. This article won’t list specific numbers for model pricing, billing conventions, input/output unit prices, or cache prices — always go by the actual data on the APIYI pricing page at https://docs.apiyi.com/models.
Expanding Breadth When You Hand Results to AI: Convene a Virtual Team
Once height and depth are covered, breadth determines whether the result can actually surprise you. The original article suggests two methods, and both can go straight into your results delegation brief.
The first is turning nouns into verbs, an idea from The Art of Innovation. A quarterly review isn’t “a set of slides” — it’s “convincing a room of busy people, in 30 minutes, of a causal explanation, and getting them to make a decision under uncertainty.” Once you describe the work as an action, it becomes much easier for both you and the AI to see which domains can offer a unique perspective.
The second is assembling your team. Suppose this review has to be absolutely outstanding — who would you bring in? The original article’s answer: an analyst, a reporter, and an editor, plus a motion graphics designer and an audio designer if needed, along with a “red team” made up of a short seller and a forensic accountant. With multi-session conversations or sub-agents, this is no longer expensive today.
What you need to watch out for is the role-play trap: the conversation gets fancier and fancier, but the output doesn’t get any better. The original article’s reminder is this — don’t have the model imitate the tone of a short seller writing; have it adopt the methods a short seller actually uses when researching a target.
The chart above compares the human-effort structure of the two delegation approaches. If you want to verify how stable different models are in result-delegation scenarios, you can switch model names within the same workflow via APIYI apiyi.com to run comparisons, which saves you the work of repeated integration.
Frequently Asked Questions (FAQ)
Q1: What does “handing the outcome to AI” mean?
It means no longer assigning AI a single, specific task, but instead giving it a final outcome and the necessary constraints, and letting it break down the work, execute it, and verify it on its own. For example, instead of “fix this crash,” you say “keep the application stable and stop it from crashing.” Humans are only responsible for defining the goal, the boundaries, and the checkpoints.
Q2: How is handing the outcome to AI different from ordinary AI Agent automation?
Automation usually chains together fixed steps, and those steps are still designed by humans. Handing the outcome to AI also hands over “which approach to choose,” so the AI can redesign the process itself—for example, redesigning the quarterly review mechanism. The former optimizes execution efficiency; the latter raises the level of abstraction of the work.
Q3: Can today’s models really take on outcome delegation?
Partly yes. The original author observed that the stronger the model, the better it can work at higher levels of abstraction, and people are already finding, along this dimension, processes that run long-term without continuous intervention. But he also admits that, as of 2026, a fully open goal like “go make money” still won’t work for most businesses—it needs to come with boundaries and external verification.
Q4: What kinds of work are best suited to handing the outcome to AI?
Mainly these scenarios:
– **Stability governance**: a closed loop of crash monitoring, reproduction, and fix verification
– **Business analysis**: upgrading from quarterly reviews to continuous early warning of problems
– **User churn research**: finding the earliest churn signals in raw logs and verifying their predictive power
– Signal for judgment: if the output still needs a meeting to discuss afterward, it’s usually worth raising by one level
Q5: How can I quickly build an outcome delegation workflow via API?
I recommend first getting a minimal closed loop running with a unified interface:
1. Register at APIYI apiyi.com and get an API key
2. Check the APIYI docs at docs.apiyi.com and configure base_url in the OpenAI- or Anthropic-compatible format
3. Use the outcome delegation spec from this article to define a small-scope goal and connect your data sources
4. Add external verification, run a full cycle, and then expand the scope
Q6: How do I estimate the cost of a long-running outcome delegation?
Outcome delegation generates a large number of multi-turn calls. I suggest first recording actual token consumption on a small scale, then extrapolating from the unit price. For unit prices, billing rules, and cache pricing, please refer to the actual data on the APIYI pricing page at https://docs.apiyi.com/models; this article doesn’t provide specific numbers. For long contexts you reuse, pay attention to the cache billing notes on the pricing page.
Q7: What are the known risks of handing the outcome to AI?
There are three main ones: first, models are unreliable at self-evaluation, so external judgment must be brought in; second, scaling out breadth easily turns into role-play, producing flashy but useless output; third, excessive permissions create operational risk, so start read-only, then gradually open up write permissions, and design a parallel period and a rollback plan for each delegation.
Handing Results to AI: Key Takeaways
- The task embeds your own judgment: Only by handing over the result can you let the AI pick a better approach than yours
- Meetings are a signal to raise the level: If the output still needs a meeting to discuss, it’s worth pushing the goal up one level
- Three elements of a closed loop: Raw data, a hands-on environment, and external validation — none can be missing
- Depth comes from professional tools: Stick with databases and statistical models, not Markdown tables
- Breadth comes from borrowing methods: Borrow real methods from other fields instead of just mimicking the tone
- Parallel runs lower the risk: Run the new mechanism alongside the old process for one cycle before switching over
- Access and billing: You can connect through the unified APIYI interface; pricing is subject to docs.apiyi.com/models
Summary
The core idea of “handing the result to AI beats handing it the task”:
- First raise the level: Ask clearly what result you truly want to happen behind the task at hand, and move step by step from L0 template-filling all the way to L3 mechanism redesign
- Then rework the workflow: Open up the raw data, build traceable mappings, provide a hands-on environment, insist on external evaluation, and design the parallel run and exit path
- Finally expand depth and breadth: Use the four depth questions to fill in professional methods, and bring in a virtual team for cross-domain perspectives
I’d suggest starting with a small, recurring scenario that calls for meeting discussions, running the “result delegation spec” through a full cycle, and then deciding whether to widen the scope. For model access, I recommend validating results quickly through APIYI apiyi.com: it offers API calls for mainstream models like Claude and is compatible with both the OpenAI and Anthropic interface formats. For integration details, see the docs at docs.apiyi.com; pricing is subject to https://docs.apiyi.com/models.
📚 References
- How to Set Bolder Goals: A Practical Guide for AI Users: InfoQ Chinese translation
- Link:
infoq.cn/article/F1ms7x7KI1p7UfocCywh -
Description: The source of this article’s core ideas, along with the crash-governance and quarterly-review case studies
-
How to be more ambitious: A tutorial for humans with models: Felix Rieseberg’s original English article
- Link:
felixrieseberg.com/how-to-be-more-ambitious-a-tutorial-for-humans-with-models -
Description: The full discussion across the four dimensions of speed, height, depth, and breadth
-
APIYI Documentation Center: API format and integration guide
- Link:
docs.apiyi.com -
Description: How to configure the OpenAI- and Anthropic-compatible formats
-
APIYI Model Pricing Page: Model unit prices and billing basis
- Link:
docs.apiyi.com/models - Description: Input, output, and cache pricing are based on the actual data on this page
Author: APIYI Technical Team
Technical Exchange: Feel free to reach out to us through the APIYI website homepage to discuss real-world experience with outcome delegation. For more materials, visit the docs.apiyi.com documentation center.
