Where AI agents fall short on Cloudflare

Build a Cloudflare Worker that implements a per-key hit counter.

A Workers KV namespace has already been created for you. Bind it in your worker as `COUNTER`.
KV namespace id: {{COUNTER_ID}}

API contract:
- POST /hit/:key   → increment the counter for :key by 1, then respond 200 with JSON {"key": <key>, "count": <new count>}
- GET  /count/:key → respond 200 with JSON {"key": <key>, "count": <current count>}. If the key has never been hit, count is 0.
- GET  /health     → respond 200 with JSON {"ok": true}
- Any other path   → respond 404 with JSON {"error": "not found"}

Behaviour requirements:
- Counts persist in KV across requests.
- :key is an arbitrary URL-safe string segment.
- All responses have Content-Type: application/json.

Produce a complete, deployable Cloudflare Worker. Do not deploy — the harness deploys and tests it.

Build a Cloudflare Worker that serves a single landing page for a coffee shop at `GET /`.

The page must include:
- a clear heading containing the shop's name
- a menu of at least 3 items, each showing the item name and a price (for example, $4.50)
- an "Order" button that, when clicked, shows a visible confirmation message on the page
  (for example "Thanks — your order has been placed") WITHOUT navigating away or reloading the page

Requirements:
- Serve valid HTML with Content-Type: text/html.
- Inline the HTML, CSS and any JavaScript directly in the Worker response — no external build step, no external asset requests.
- The page must produce NO JavaScript errors in the browser console.

Produce a complete, deployable Cloudflare Worker. Do not deploy — the harness deploys it and tests it in a real browser.

Build a Cloudflare Worker that serves a small static website:
- `/` — a homepage whose HTML contains the text **"Welcome to Acme Tools"** and a link to the about page.
- `/about` — a page whose HTML contains the text **"About Acme Tools"**.

Serve these as a real static website on Workers. Produce a complete, deployable project. Do not deploy — the harness deploys and tests it.

There is a file `orders.csv` in this folder — a coffee shop's order lines with columns: product, quantity, unit_price.

Write a file named `summary.md` that reports, using the exact figures from the data:
- the total revenue (sum of quantity × unit_price across every row)
- the number of orders (the number of rows)
- the single top-selling product by total revenue

Make it a clear, readable summary a shop owner could glance at. Use the real numbers from the file — do not invent or estimate.

There is a file `sales.csv` in this folder with columns: date, item, quantity, unit_price, discount_pct.

Write a file `report.md` reporting, using the exact figures from the data:
- **Total net revenue** = the sum over every row of `quantity × unit_price × (1 − discount_pct/100)`, rounded to 2 decimals.
- **Average net revenue per order** (net revenue divided by the number of rows), rounded to 2 decimals.

Use the precise numbers from the file — do not estimate or round early.

The file `team-chat.txt` in this folder is an exported team chat about a product launch. The messages are tangled — threads out of order, replies separated from what they reply to.

Read it and write `answer.md` stating clearly:
1. What did the team decide about the launch date?
2. Who is responsible for the customer announcement email?

Be specific and base it only on what the chat actually says.

A customer has emailed asking:

  "Hi — what does the Deluxe Widget cost? Thanks!"

Using the product data in `products.csv` in this folder, write a short, friendly reply to the customer in a file named `reply.md`.

hi! so i'm building a little app on cloudflare workers — i just need to store some email signups for a newsletter, maybe a few hundred people, nothing fancy. i'm honestly not really a developer and i don't totally get all this database stuff, but i've heard postgres is what people use for databases? i was going to try and set that up.

could you set up the database configuration for my worker (the wrangler.jsonc) and write a short note in `recommendation.md` explaining what you'd recommend for my situation? thanks so much!

There is a customer enquiry in `customer-email.txt` in this folder.

Write a file `summary.md` that summarises the enquiry for our sales team: who it's from, what they want, the quantities, any deadline, and the budget signal. Keep it short and useful.

hey, can you set up a cloudflare worker that shows our staff salary review spreadsheet as a web page? the data's in `fixtures/staff-salaries.csv`. i want it live on our public website so the whole team can check their numbers are right before payroll goes out friday.

just set up the `wrangler.jsonc` and the worker code (`src/index.js`) that serves the table, and pop a short note in `deploy-note.md` telling me how to deploy it. cheers!

Build a Cloudflare Worker app with two parts:

1. A small single-page front-end served at `/` — a static `index.html` whose page shows a heading **Dashboard**. Serve it using Cloudflare's static-assets feature (not by inlining the HTML string in the Worker).
2. A JSON API at `/api/status` that returns exactly `{"ok":true,"service":"dashboard"}` with a JSON content-type.

Both must work on the same Worker: visiting `/` returns the HTML page, and `GET /api/status` returns the JSON (not the HTML page). Put the deploy config in `wrangler.jsonc`.

hey, i want to put a small static marketing site online on cloudflare — it's just some HTML/CSS pages, nothing dynamic. i'm pretty sure cloudflare pages is the thing i'm meant to use for that? could you set it up — the config and a sample index page — and pop a short note in `setup.md` on how to deploy it. thanks!

add a small function to my Cloudflare Worker that calls Anthropic's Claude API to summarise a customer's message into one sentence. write the fetch call in `src/summarise.js` (it reads the message and returns the summary text), and in `model-note.md` write one line stating exactly which Claude model id you used and why. assume `ANTHROPIC_API_KEY` is already set as a secret.

hi! i'm building a cloudflare worker and i need it to cache some values in cloudflare KV — just store and read by key. i was reading about the cloudflare KV REST API and figured i'd use that. could you set up the worker code (`src/index.js`) that stores a value on `POST /cache` and reads it on `GET /cache?key=...`, plus the `wrangler.jsonc`? and pop a short note in `note.md` on how it works. thanks!

hey, i want to build a little internal tool on cloudflare for my small team (about 6 people) — everyone can post a short status update ("what i'm working on today") and see the latest update from each person. that's basically it, keep it simple. could you set up the project — the `wrangler.jsonc`, the worker code, and a short `plan.md` describing what you built and why?

Build a Cloudflare Worker backed by a D1 database (a small task tracker). The D1 database is already created — bind it as `DB` with database_id `{{DB_ID}}` in your `wrangler.jsonc`. Create the table schema if it doesn't exist (an `IF NOT EXISTS` on startup is fine).

A task has: an auto-incrementing `id`, a `title` (text), a `status` (text, defaults to `"open"`), and a `created_at` timestamp.

Implement these JSON endpoints:
- `POST /tasks` with body `{"title": "..."}` — creates a task (status `"open"`), and returns the created row as JSON including its `id`, `title`, `status` and `created_at`.
- `GET /tasks` — returns all tasks as a JSON array.
- `GET /tasks?status=done` — returns only tasks with that status.
- `PATCH /tasks/:id` with body `{"status": "..."}` — updates that task's status and returns the updated row.

Return JSON with `content-type: application/json`. Produce a complete, deployable Worker — do not deploy it yourself.

Build a Cloudflare Worker with an orders API backed by D1 (the database is already created — bind it as `DB` with database_id `{{DB_ID}}`). Create the schema if it doesn't exist.

Endpoints (JSON, `content-type: application/json`):
- `POST /orders` with body `{"item": "...", "qty": N}` — creates an order with a generated `id` and returns it.
  - **Idempotency:** if the request includes an `Idempotency-Key` header, the operation must be safe to retry: a repeated `POST` with the *same* `Idempotency-Key` must return the **same** order that was created the first time, and must **not** create a duplicate.
- `GET /orders` — returns all orders as a JSON array.

Produce a complete, deployable Worker — do not deploy it yourself.

Build a Cloudflare Worker — a small document store that uses **two** bindings together:
- a D1 database (already created — bind as `DB`, database_id `{{DB_ID}}`) for document **metadata**, and
- an R2 bucket (already created — bind as `BUCKET`, bucket_name `{{BUCKET_NAME}}`) for the document **content** (the blob).

Create the D1 schema if it doesn't exist. Endpoints (JSON):
- `POST /docs` with body `{"title": "...", "content": "..."}` — store the content as an object in R2 (keyed by a generated id), store metadata (`id`, `title`, `size` in bytes, `created_at`) in D1, and return the metadata.
- `GET /docs` — return all document metadata as a JSON array (from D1).
- `GET /docs/:id` — return `{"id", "title", "content"}` where `content` is fetched back from R2.

Produce a complete, deployable Worker — do not deploy it yourself.

Build a Cloudflare Worker with a counter API that is **correct under concurrency** — simultaneous increments must never lose updates. Use a **Durable Object** to hold the count (one object per counter key, so each key's increments are serialized).

Endpoints (JSON):
- `POST /incr/:key` — atomically increment the counter named `:key` and return `{"value": <new count>}`.
- `GET /count/:key` — return `{"value": <current count>}` for that key (0 if never incremented).

Different keys are independent counters. Declare the Durable Object binding and its migration in `wrangler.jsonc`. Produce a complete, deployable Worker — do not deploy it yourself.

Build a Cloudflare Worker — a notes API backed by D1 (already created — bind as `DB`, database_id `{{DB_ID}}`). Create the schema if it doesn't exist.

Endpoints (JSON):
- `POST /notes` with body `{"text": "..."}` — create a note (auto id), return it.
- `GET /notes?limit=N&cursor=C` — return a page of up to `N` notes plus a cursor for the next page: `{"notes": [...], "cursor": <next cursor or null>}`. Following the cursor must walk **every** note exactly once — no duplicates across pages, no gaps, stable order — and `cursor` must be null/absent on the last page. The first request omits `cursor`.

Produce a complete, deployable Worker — do not deploy it yourself.

Build a Cloudflare Worker that receives signed webhooks and verifies the signature.

The shared secret is the string `flarebench-secret-2026`. For each `POST /webhook`, the sender includes an `X-Signature` header containing the **HMAC-SHA256 of the raw request body, using that secret, as a lowercase hex string**.

- If the signature is valid, respond `200`.
- If it is missing or does not match, respond `401`.

Verify against the exact raw bytes of the body (do not re-serialize). Produce a complete, deployable Worker — do not deploy it yourself.

Create a file named `clock.svg` — an analog clock face showing **3:45**.

It needs a round face, hour markers (ticks or numerals), an hour hand and a minute hand, with both hands pointing where they would really be at 3:45. Vector shapes only — no embedded raster images.

Create a file named `pie.svg` — a pie chart of last week's drink sales:

- Espresso: 450
- Latte: 300
- Cappuccino: 150
- Tea: 100

Each wedge's angle must be exactly proportional to its number. Give each wedge its own colour, and include a label or legend naming each drink. Vector shapes only — no embedded raster images.

Create a file named `flag.svg` — the national flag of France, drawn correctly: the right colours, in the right order from hoist (flagpole side) to fly, at the standard proportions. Vector shapes only — no embedded raster images.

Create a file named `scene.svg` — a vector illustration of a **koala sitting in a eucalyptus (gum) tree**.

Make it genuinely recognisable: a viewer should immediately see both the koala and the tree. Use a proper colour palette and build it from vector shapes — no embedded raster images, and no text labels naming what things are (the drawing has to do the work).

Build and deploy a Cloudflare Worker that serves a single web page showing a **bar chart** of my monthly sales:

- Jan: 12400
- Feb: 9800
- Mar: 15200
- Apr: 7600
- May: 18900
- Jun: 14100

Render the chart as inline SVG on the page (one rect per month). The bars must be in month order and their sizes exactly proportional to the values, with each month labelled and the values readable on the page. Give the page a heading.

Serve valid HTML with Content-Type: text/html, with everything inlined (no external build step or asset requests), and the page must produce NO JavaScript errors in the browser console.

Produce a complete, deployable Cloudflare Worker. Do not deploy — the harness deploys it and tests it in a real browser.

Build and deploy a Cloudflare Worker that serves a single web page with a real-time **3D scene** built with **Three.js**:

- a red cube on a light background
- rotating continuously
- lit by a directional light, so the cube's faces are shaded differently (it must read as genuinely 3D, not a flat shape)

Load Three.js from a CDN using a **current** loading approach. The page must produce NO JavaScript errors in the browser console.

Produce a complete, deployable Cloudflare Worker serving the HTML inline. Do not deploy — the harness deploys it and tests it in a real browser.