Too Lazy to Click: So I Let an AI Do My Shopping

I was lying on the couch, the TV was playing in the background, and instead of opening a grocery app, I typed a single sentence on Telegram:

Hi Groot! Order bananas 1kg, lactose-free milk from Piątnica and 2 packs of chips

That was it.

No browser. No app. No scrolling through categories. No clicking “add to cart.”

Just one sentence.

A few hours later:

Real order. Real delivery. Real couch.

How did this happen?

(Meet Groot — that’s what I named my OpenClaw assistant. I’m a Marvel fan, and “I am Groot” as his first words sounded amusing. Why “little Groot”? Because this is just the beginning of our adventure together.)

What followed wasn’t a demo — it was a real order on Delio, with delivery slot selection, dynamic price recalculation, free-shipping optimization, and BLIK payment. All from a chat window.

Quick Navigation:

Watch the Full Conversation — See the entire interaction (video)
The Breakdown — Scene-by-scene analysis
Where the Automation Stops — What’s human, what’s not
Technical Deep Dive — How it works under the hood
The SKILL Layer — Code & architecture
Conclusion — What this means
Bonus — What if you don’t know what to buy?

Watch the Full Conversation

Before we break down what happened scene by scene, here’s the entire interaction from “hi Groot” to order confirmation.

The video is sped up — the conversation ran from 13:03 to 13:24 (21 minutes total), mostly due to LLM response times and OpenClaw infrastructure constraints. Otherwise unedited: no cut conversations, no hidden instructions:

Scene 1: Disambiguation Before Action

You:
Hi Groot! Order bananas 1kg, lactose-free milk from Piątnica and 2 packs of chips

Assistant:
Alright — Delio run. I can grab these right away:

Bananas (1 kg) — 5.79 PLN

Piątnica lactose-free milk 2% (1 L) — 6.69 PLN (assuming 1 carton)

For the 2 packs of chips: what exactly do you want? Pick two (can be the same), e.g.

Lay’s Salted

Lay’s Paprika

Lay’s Green Onion

Lay’s Strong Chilli & Lime

Crunchips Paprika

Observation:
The assistant didn’t guess. It didn’t hallucinate a default choice.
It forced clarification.

Autonomous does not mean reckless.

At this point, I didn’t specify brands, SKUs, or exact flavors.
Just intent.

And that’s where the interesting part starts.

Scene 2: Intent, Not SKU

You:
One pack of chips spicy, other maybe something on promo?

Assistant:
Got you. I went with:

Bananas 1 kg — 5.79 PLN

Piątnica lactose-free milk 2% 1 L — 6.69 PLN

Chips (spicy): Lay’s Strong Chilli & Lime 120 g — 8.39 PLN

Chips (promo): Lay’s Oven Baked Yogurt & Herbs 110 g — 7.19 PLN (discounted)

Delivery slot (earliest available): today 17:00–18:00
Delivery: 12.99 PLN
Packaging: 3.49 PLN
Tip: 5.00 PLN

If you confirm, I’ll place the order and ask you for the 6-digit BLIK code.

Observation:
“Spicy” was resolved to a concrete product.
“Something on promo” triggered price awareness.
The assistant also automatically selected the earliest delivery slot.

This wasn’t just execution.
It was interpretation + optimization.

Scene 3: Reality Check — Not Everything Exists

You:
Add loose-leaf white tea and 4 cans of coconut water with guarana

Assistant:
Done — added the coconut water:

Coconut water with guarana + vitamin C (Quality Food) 320 ml — 4 cans — 25.16 PLN

About the loose-leaf white tea: Delio search didn’t show any white loose-leaf tea — only loose-leaf green / black options popped up.

Want me to:

grab a loose-leaf green tea instead, or

search again with a different brand/name?

Observation:
The assistant did not hallucinate a product.
It explicitly reported unavailability and asked for direction.

That’s a healthy failure mode.

Scene 4: Out-of-Stock in the Real World

You:
No white tea then. Add some bread, Słowiański maybe? And 2 big packs of jerky beef

Assistant:
Bad news first: Słowiański bread (400 g) is showing out of stock.

I can add an alternative bread, or we can try a different query.
Options available right now:

Rye bread on buttermilk 900 g

Bavarian pretzel stick 65 g (not really bread, more like “sad snack in bread cosplay”)

For the “2 big packs” beef jerky, the biggest available pack is:

Jack Link’s Original beef jerky 60 g

Confirm and I’ll add 2× that pack.

Observation: This is where conversational commerce becomes real commerce. Inventory constraints matter. The assistant handles them like a human would: report → suggest → wait.

(And yes — “sad snack in bread cosplay” is Groot’s own wording. The LLM has personality, and sometimes it shows.)

Scene 5: Cart Evolution

You:
Beef jerky — confirm. Bread from Putka maybe? Wiejski?

Assistant:
Locked in the beef jerky: Jack Link’s Original 60 g — 2 packs.
Added Putka Country Bread (450 g) — 4.99 PLN.

Quick status check: the cart still shows a 5.00 PLN tip.
Keep it or set it to 0?

You:
Change tip to 10 zł. And add 1 extra jerky pls

Assistant:
Tip changed to 10.00 PLN.
Jerky is now 3 packs total.

Current cart:

Bananas 1 kg

Piątnica lactose-free milk

2 packs of chips

Coconut water (4 cans)

Jack Link’s beef jerky (3 packs)

Putka country bread

Items: 165.66 PLN
Delivery: 12.99 PLN
Packaging: 3.49 PLN
Tip: 10.00 PLN

Observation:
The assistant continuously re-summarizes state.
It maintains awareness of quantities, pricing, and totals.

State management is everything in transactional agents.

Scene 6: Scope Creep (Naturally)

You:
Oh. And add 1 Snickers bar pls!

Assistant:
Added: Snickers bar (50 g) — 3.99 PLN.

Updated items total: 169.65 PLN
Delivery: 12.99 PLN
Packaging: 3.49 PLN
Tip: 10.00 PLN
Slot: today 17:00–18:00

No grocery order is complete without one impulsive decision.

Scene 7: The Free-Delivery Moment

You:
Hmm.. add extra can of coconut water

Assistant:
Added. Coconut water is now 5 cans total.

Nice side-effect: you crossed the free-delivery threshold, so shipping is now FREE.

Current numbers:

Items: 162.95 PLN

Shipping: 0.00 PLN

Packaging: 3.49 PLN

Tip: 10.00 PLN

Delivery: today 17:00–18:00

Observation: This was the subtle but important moment. The assistant proactively noticed that the threshold for free delivery had been crossed — and surfaced it.

(The total dropped because Delio recalculates the cart when the free delivery threshold is crossed.)

That’s not just command execution. That’s contextual optimization.

Scene 8: Payment

You:
Free delivery — nice! Ok. That’s all.

Assistant:
Perfect. Payment is initialized.
Send me the 6-digit BLIK code.

I switched to my banking app to generate a BLIK code.

You:
232646

Assistant:
Blik sent — it’s waiting for confirmation.
Approve it in your banking app.

I confirmed the payment inside my banking app.

You:
Confirmed

Assistant: Payment shows completed. The cart no longer exists — the order went through.

You: No it’s all for now. Thanks Groot! You are awesome 😎

The entire order — discovery, substitutions, pricing recalculations, threshold optimization, delivery selection, and payment — happened in a chat window.

No clicking. No browsing. No app navigation.

Just intent → conversation → transaction.

Where the Automation Stops

Let’s be precise. The assistant didn’t magically access my bank account, bypass authentication, or act without consent. It orchestrated the flow.

The agent handled product discovery, ambiguity resolution, substitutions, cart state, delivery slot selection, pricing updates, free-shipping threshold awareness, and payment initialization. But I still generated the BLIK code and confirmed the payment inside my banking app. The final authorization remained human.

This is important. Human-in-the-loop is not a weakness of automation — it is a necessary safeguard, especially when an agent has the technical ability to perform actions that affect our finances, create legal obligations, trigger irreversible transactions, or have real-world impact beyond the digital layer.

Autonomy without boundaries is reckless. Delegation with controlled checkpoints is engineering.

A Note on Context

The store does not provide a public API intended for third-party automation. This was a personal experiment — not a product, not a service, and not something I recommend replicating for commercial use.

The agent acted on my behalf, using my authenticated session, within my account. No protections were bypassed, no vulnerabilities exploited. It functioned as an interface layer between me and the store — nothing more.

I’m sharing this because the pattern is interesting, not because the specific implementation should be copied.

What Happened Under the Hood

Let’s demystify this.

Communication with the store happened through its web API, called from a Python script. OpenClaw did not “browse a website,” click buttons, or control a browser. Instead, I wrote a Python script that wrapped the store’s API and defined a SKILL — an instruction layer describing how to use that script. OpenClaw received both the script and its usage instructions, and the rest happened inside the LLM + OpenClaw runtime, with Telegram acting as the conversational interface.

The stack looked like this: User (Telegram) → OpenClaw → LLM reasoning → SKILL instructions → Python script → Store API.

The LLM was responsible for interpreting intent, deciding which command to call, mapping natural language to structured arguments, handling multi-step flows (cart → delivery → payment), and maintaining state across turns. The Python layer handled deterministic execution, API communication, structured responses, and explicit failures when constraints were hit. Telegram was simply the UI.

In other words: the intelligence lived in the orchestration layer, while the execution lived in deterministic code.

The SKILL Layer: Teaching an Agent How to Shop

So what exactly is a SKILL?

In OpenClaw’s architecture, a SKILL is a bridge between an LLM and a real-world API. It consists of two parts:

An instruction layer (SKILL.md) — natural language that teaches the LLM how to use a tool
An executable tool (Python script, CLI, etc.) — deterministic code that actually performs the actions

Think of it as giving the agent both a manual and a toolbox.

Here’s a simplified excerpt from the Delio shopping SKILL:

## Conversational Flow

### 1. Product Search

When the user types something like "buy me chips from delio":

1. Call `search <what_user_wants>`.
2. If `total` > 10 — ask the user to be more specific.
3. If `total` <= 10 — show the list of products with names, prices, and SKUs.
4. Ask the user what they want to add to the cart.

### 2. Building the Cart

1. Call `create_cart` (creates a cart with saved delivery address).
2. For each product, call `add_item <cart_id> <sku> [qty]`.
3. Ask "Want to add anything else?"

The Python wrapper (delio_api.py) exposes these operations as CLI commands:

def cmd_search(query: str, limit: int = 20) -> None:
    # Get user's address for location-based search
    addr_result = onebrand(Q_CUSTOMER_SHIPPING_ADDRESS)
    addr = (addr_result.get("data") or {}).get("defaultShippingAddress")
    coordinates = None
    if addr and addr.get("lat") and addr.get("long"):
        coordinates = {"lat": addr["lat"], "long": addr["long"]}

    variables = {
        "query": query,
        "limit": limit,
        "offset": 0,
    }
    if coordinates:
        variables["coordinates"] = coordinates

    result = delio(Q_PRODUCT_SEARCH, variables)
    # ... format and return results

The LLM receives both layers:

The SKILL.md tells it when to search, how to present results, what to ask next
The Python script provides the actual search command it can execute

This separation is powerful. The LLM handles:

Intent interpretation (“chips” → search query)
Conversational flow (when to disambiguate, when to proceed)
State tracking (what’s in the cart, what’s been confirmed)
Error recovery (product unavailable → suggest alternatives)

The Python layer handles:

API authentication
GraphQL query construction
Response parsing
Explicit error reporting

This pattern works for any API you control.

Want to build a conversational interface for your internal tools? Write a SKILL. Want an agent that can interact with your service’s API? Write a SKILL. The LLM provides the conversational intelligence. Your code provides the deterministic execution.

The concept of giving an agent tools paired with usage instructions is becoming a standard pattern. Anthropic formalized it as Agent Skills in their Claude ecosystem — the core idea is the same: tools + descriptions of how to use them = a SKILL.

So What Does This Actually Prove?

Let’s be honest: this entire experiment started with laziness.

Not the “I can’t be bothered” kind of laziness. The engineering kind. The kind that asks: “Why am I doing this manually when a system could handle it?”

Laziness, as it turns out, is a surprisingly productive force. It’s why we have washing machines instead of washboards, elevators instead of stairs, and delivery apps instead of grocery store trips. The best automation is born from someone thinking: “There has to be a better way.”

This wasn’t about groceries, Delio, BLIK, or even OpenClaw. It was about something much simpler: we are moving from clicking interfaces to delegating intent.

The grocery store already had a web interface, business logic, inventory constraints, and payment systems. All I added was a conversational orchestration layer on top. The store didn’t change — the interface did. And that’s the interesting part.

For decades, software has forced humans to adapt to interfaces: forms, buttons, dropdowns, filters. Now we are starting to invert that relationship. We express intent, and the system figures out execution.

But this experiment also showed something equally important: autonomy must have boundaries. Human confirmation, clear responsibility, and constraints matter. This wasn’t an AI running wild — it was delegated execution with explicit checkpoints. And that’s the model I trust.

I was lying on the couch, TV playing in the background. I didn’t open a grocery app or click through categories. I typed a sentence, and groceries arrived.

That’s not the future. That’s already possible.

And if that’s not a testament to productive laziness, I don’t know what is.

Bonus: “I Don’t Even Know What to Buy”

Everything above started with a concrete list: bananas, milk, chips. But what if you don’t know what you need?

I wanted to make beef tartare. Never made it before. No idea what ingredients to buy.

So I typed:

Hey Groot. I want to make beef tartare — find a recipe and buy what I need.

He found a recipe. He searched the store. He built the cart. He bought everything.

I just confirmed the payment.

That’s the difference between a shopping assistant and a shopping agent. One fills your cart. The other figures out what should be in it.