How I automated eBay listings for my card shop

I sell trading cards, and I have thousands of single cards to list. The selling is fine. The listing is the part that eats a night: identify the card, find what it has actually sold for, write an 80-character title, pick the right category, and remember which box the thing lives in.

So I built a pipeline to do it. I take the photos. I review each draft and publish it myself. Everything between those two ends is code or AI.

This series walks through all of it: how it works, what went wrong, what it costs, and where the AI’s effort goes. This first part is the tour. You don’t need to write code to follow it.

The whole thing on one page§

Here is every step of one run, in order.

The pipeline, start to finish

• MeA person decides
• CodeA fixed program decides, the same way every time
• AIThe AI uses its eyes or its judgment

Before the run

1. 1

   Step 1: Sort and photographMe

   I sort fifty cards by condition, then photograph the front and back of each one. A hundred photos go into one shared folder.

   Uses: Camera, Google Drive

The run, at 2:00 a.m.

2. 2

   Step 2: Check the folderCode

   A program counts the photos. It wants exactly a hundred, all readable, with no duplicates. It waits two minutes and counts again, in case I’m still uploading.

   Uses: Google Drive

3. 3

   Step 3: Give every card an addressCode

   Each card gets a row in a spreadsheet and a SKU that says where it will live: which box, which section, which slot.

   Uses: Google Sheets

4. 4

   Step 4: Publish the photosCode

   eBay needs a web link for every photo. A program checks each image, then publishes the photos, and only the photos.

   Uses: A small image site

5. 5

   Step 5: Identify each cardAI

   The AI looks at both sides of a card, finds the official checklist for its set, lists every version it could be, and looks for a second source that shows the same card.

   Uses: AI vision, web research

6. 6

   Step 6: Check the AI’s workCode

   A program takes the AI’s evidence and makes the decision. One version left, backed by two sources: verified. Anything less, and the card waits for me.

   Uses: The pipeline’s own code

7. 7

   Step 7: Research the market priceAI

   The AI searches what that exact card has sold for and suggests a price. Not enough sales means no price.

   Uses: eBay sold listings

8. 8

   Step 8: Build the eBay fileCode

   A program fills in eBay’s template: title, category, card details, and photo links. A title over 80 characters stops the run.

   Uses: eBay’s own draft template

9. 9

   Step 9: Upload, then read every draft backAI

   The AI uploads the file in my signed-in browser, opens each draft, fills in what eBay dropped, saves it, reopens it, and reads it back.

   Uses: eBay Seller Hub, in a browser

After the run

10. 10

    Step 10: Review and publishMe

    I read each draft, set the final price, and publish it. About 30 seconds a card.

    Uses: Phone or computer

Three kinds of worker show up in that list, and the split matters more than any tool:

• Me. Two steps: the first and the last.
• Code. Ordinary programs that do the same thing every time. They count, check, and build files.
• AI. The steps that need eyes or judgment: reading a photo, researching a card, working a website.

If you remember one thing from this post, make it that split. Most of what people call “an AI automation” is ordinary code with a few AI steps in the middle.

The tools it connects§

Nothing here is exotic. You may already use most of these.

The connected tools

• The inboxGoogle DriveOne shared folder. Photos go in, and the pipeline picks them up from there.
• The recordGoogle SheetsOne row per card: its SKU, what it is, its price, and where it stands. If the sheet and anything else disagree, the sheet wins.
• The photo linksA small image siteIt holds the card photos, and nothing else, at web addresses eBay can show.
• The destinationeBay Seller HubWhere drafts are created from one uploaded file, and where I publish.
• The operatorOpenAI CodexThe AI agent. It runs on my Mac on a schedule. It can run programs, look at images, and work a web browser.
• The rulesThe pipeline’s own codeAbout 2,000 lines of ordinary code and about 90 tests. It counts, checks, and builds, the same way every time.

The AI agent is the operator. It’s the one that opens the folder, runs each program, and works the browser. But on most steps it isn’t deciding anything. A program does the work and checks the result, and the agent moves on to the next step.

The instructions§

“Prompt” makes it sound like one clever sentence. Mine has three layers:

1. The procedure. The manual process, written down step by step, before any AI was involved. It started at version 1.0 on August 20. It’s on 2.11 now.
2. The standing orders. What the worker may do, what it must never do, and when to stop and ask me.
3. The nightly note. A few paragraphs that start each run and point at the other two.

Here are two pieces of the nightly note, exactly as the AI reads them:

Never invent identity, sold prices, condition, origin, or profitability

Matt alone reviews and publishes. Never publish, end, edit live listings, delete eBay drafts/listings or Site photos, change policies/offer thresholds/access, create credentials, buy anything, or expose private manifests/secrets.

Put simply: it can get everything ready, but it can’t publish, delete, spend money, or change how my store is set up.

Most of my instructions read like that. Very little of it is “be smart.” Most of it is “here’s where to stop.”

The code§

The code is about 2,000 lines, with about 90 tests. It does the jobs that shouldn’t be left to something that can have a creative day: counting photos, catching duplicates, building titles, and enforcing eBay’s limits.

You don’t need to read code to see what it’s for. Here’s one real line:

if (title.length > maximum) throw new Error(`${identity.sku}: verified high-priority title facts exceed ${maximum} characters`);

It says: if the title is longer than 80 characters, stop the run and say which card. The AI doesn’t get a vote.

The most important program is the one in step 6. The AI gathers the evidence for each card. The code decides whether it’s enough. A card is marked verified only when all four of these are true:

• Exactly one version of the card is still possible.
• The basics read from the photos are complete.
• An official checklist, the maker’s own list of every card in the set, backs it up.
• A second, independent source shows the same card.

Miss any one, and the card is set aside for me. The code can’t look at a card, and it doesn’t try to. My notes say it this way:

The harness does not pretend that deterministic code can see foil.

“Deterministic” is a programmer’s word for “does the same thing every time.” Foil is the shiny finish that often tells one version of a card from another. Code can’t see it. The AI can. So each one gets the job it’s good at.

What stays mine§

Three things never leave my hands:

• Condition. I sort every stack by condition before the camera comes out.
• The final price. The AI suggests one from sold listings. I set it.
• Publishing. No command in the pipeline can publish a listing. That click is mine.

Why automate everything except the last click? Because the last click is the one with consequences.

What the morning looks like§

When a run goes well, the drafts are waiting for me, along with a short list of any cards the pipeline wasn’t sure about. I read each draft, set the final price, and publish, from my phone or my computer. It takes me about 30 seconds a card.

It didn’t start out that smooth. Part two is everything that went wrong, and the rules that came out of it.

If you sell things online§

The same shape works for anything with photos, details, and a marketplace at the end of it. I wrote more about the pipeline itself, and it’s the kind of work I take on for other small businesses under AI and workflow automation.

If you’ve got a pile of something that needs listing, tell me about it.