# Four real requests, and what they compiled to

> Real requests, typed by real people, typos included. What each one compiled to, which needed a second attempt, and where the answer surprised them.

- Source: https://defiloops.com/blog/four-things-people-actually-asked
- Published: 2026-08-11
- Category: Strategy
- Tags: worked-example, lending, bridging, rwa, routing
- Author: DeFiLoops

---
Everything below was typed into the product by somebody who was not us. The wording is
theirs. I have kept the spelling, because the spelling is part of the point: this is not a
query language, and people do not compose their sentences carefully before pressing enter.

## 1. "take $100 usdc from my account and buy cbBTC and send me back"

The simplest possible request, and a good one to start with because almost nothing about it
is ambiguous.

<StepBoard title="What it compiled to" steps={[
  { op: 'deposit.pull',   name: 'pull-100',   detail: '$100 USDC from wallet',    chain: 'base', pill: '1 call' },
  { op: 'swap.router',    name: 'buy-cbbtc',  detail: "← linked step's output",   chain: 'base', pill: '2 calls' },
  { op: 'transfer.erc20', name: 'send-back',  detail: 'cbBTC to your wallet',     chain: 'base', pill: '1 call' },
]} />

Three steps, one network, one signature. Note step one: the money did not have to be moved
to the operating account in advance. `deposit.pull` draws it from your own wallet against
an allowance, at the moment the run needs it.

<Callout type="note" title="Approving is not depositing">
  Granting the allowance moves nothing, and you can revoke it in your own wallet like any
  other. This is the part people expect to be a deposit step, and it is not one.
</Callout>

## 2. "Now take 2k usdc, spilit it four. And lend it as usdc into different lending protocols. Choose the best four performence"

Now it gets interesting, because "the best four" is not something the person asking knows —
it is something the plan has to find out.

<StepBoard title="Four ways, one instruction" steps={[
  { op: 'deposit.pull', name: 'pull-2000',   detail: '$2,000 USDC from wallet',  chain: 'base',     pill: '1 call' },
  { op: 'lend.supply',  name: 'supply-aave3', detail: '500 USDC · Aave v3',      chain: 'base',     pill: '2 calls' },
  { op: 'lend.supply',  name: 'supply-morpho', detail: '500 USDC · Morpho',      chain: 'base',     pill: '2 calls' },
  { op: 'bridge.cctp',  name: 'cross-arb',    detail: '1,000 USDC · Circle',     chain: 'base→arb', pill: 'off-chain', brk: true },
  { op: 'lend.supply',  name: 'supply-arb',   detail: '500 USDC · Aave v3',      chain: 'arbitrum', pill: '2 calls' },
  { op: 'lend.supply',  name: 'supply-arb-2', detail: '500 USDC · Morpho',       chain: 'arbitrum', pill: '2 calls' },
]} />

Two things worth reading off that board.

**The two supplies on the same network run at the same time.** The order is worked out from
what depends on what, not taken from the order the person listed things in. Nothing about
supplying to Aave depends on the Morpho supply having finished, so they do not queue.

**The dotted line is a fifteen-minute wait.** Crossing between networks goes through
Circle's official route, takes about fifteen minutes, and cannot be hurried. The plan is
built around that: the steps on the far side cannot start early.

<Callout type="warn" title="Four protocols is not automatically better than one">
  Splitting four ways spreads protocol risk. It also pays four sets of fees and two
  crossings, and the fourth-best rate is, by definition, worse than the first. Ask what the
  spread between them actually is before assuming the diversification is free.
</Callout>

## 3. "take base $100 usdc from my account and buy XAUT from ethereum"

This one is the most instructive, because the interesting work is the part nobody asked for.

The person has USDC on Base. They want tokenized gold, which is on Ethereum. That sentence
contains a network crossing they did not mention and probably were not thinking about.

<StepBoard title="The crossing nobody asked for" steps={[
  { op: 'deposit.pull', name: 'pull-100',   detail: '$100 USDC from wallet',   chain: 'base',     pill: '1 call' },
  { op: 'bridge.cctp',  name: 'to-ethereum', detail: '100 USDC · ~15 minutes', chain: 'base→eth', pill: 'off-chain', brk: true },
  { op: 'swap.router',  name: 'buy-xaut',   detail: "← linked step's output",  chain: 'ethereum', pill: '2 calls' },
]} />

<Callout type="danger" title="Only USDC crosses">
  The crossing in the catalogue carries USDC and nothing else. That is why step 2 moves
  dollars and step 3 does the buying — the alternative shape, buying gold on Base and
  bridging the gold, cannot be expressed. A plan that tried would be refused when it was
  written rather than failing halfway across.
</Callout>

This is also why "can I do this?" is usually the wrong question. The right one is "can I do
this *on that network*", and the two have different answers often enough to matter.

## 4. "Take $1000 usdc from my account on base and deposit to top lending pools with higy apy on all chains"

I am including this one because it took four attempts, and the reason is worth more than a
clean example would be.

The first three runs produced a plan, and the person pressed build, and then — looking at
it — asked for something different. On the fourth they wrote:

<Quote>
  Keep the three-chain split. Write the pipeline document and save it.
</Quote>

That is the request working correctly. The conversation is not the product; the plan is.
Three rounds of "not quite that" cost nothing, because none of them spent anything.

<Compare left="What people expect from a chat product" right="What this actually is" verdict>
  <Fragment slot="left">
    You type a sentence and it does the thing. A misunderstanding costs you money.
  </Fragment>
  <Fragment slot="right">
    You type a sentence and get a plan. Saving it runs nothing. Pressing Run is a separate,
    deliberate decision.

    A misunderstanding costs you thirty seconds.
  </Fragment>
</Compare>

## The pattern across all four

Nobody described steps. Every one of these described an **outcome** and left the routing,
the ordering, the approvals and the waiting to be worked out.

And in three of the four, the compiled plan contained something the person had not
mentioned: a crossing, a parallelisation, or a pull from their own wallet instead of a
deposit.

<Callout type="note" title="Read the plain-units column">
  Every amount in a plan appears twice — once as the raw integer the machine uses, once as
  "0.5 ETH" in ordinary units. A plan where every amount is a thousand times too small is
  perfectly consistent with itself and passes every other check. The plain-units column is
  the one that catches a misplaced decimal point.
</Callout>

## What to do with this

If you are about to try it, copy one of the sentences above verbatim. They are not
carefully worded and they work. Then read what comes back — particularly the steps you did
not ask for, because that is where the product is actually doing something.

And if the plan is not what you meant, say so. That round costs nothing.