Why Cowork Can't Edit an Image You Pasted: Chat Images vs. Files in a Connected Folder

I was swapping out the hero image on a client website one afternoon. I pasted the artwork photo straight into the chat and asked Cowork, "Crop this to 16:9 and export it at 1920px wide."

What came back was a thoughtful description of the composition. But as soon as the work moved on to actually cropping, it stopped: the image file couldn't be found in the working folder. Claude could clearly see the photo, yet couldn't touch it. I assumed something was broken and pasted the same image two more times.

The short version, before anything else: nothing was broken. There are two ways to hand Cowork an image, and I was only using one of them.

"It can see it" is not the same as "it has the file"

There are two paths into a Cowork conversation.

A pasted image is part of the conversation — something you show Claude. Cropping and resizing, on the other hand, are done by a program running inside the working environment. In my testing, a pasted image didn't exist there as a file. From the program's point of view, there was simply nothing to open.

Files added with the attach button sometimes do land in a working location. But that can vary with how and where you attach them, so I've stopped assuming. I'd rather run the quick check below first.

What to check when it stops

When you get "file not found," check these three things in order before pasting again:

1. Is the image actually in the folder? Ask Cowork, "Please list the contents of the connected folder." If no file name shows up, you most likely only pasted it.
2. Is a folder connected at all? Without a selected working folder, there's nowhere for files to live. Look at the screen and confirm one is chosen.
3. Does the file name match? Name the file — top_hero.jpg — instead of saying "the photo" or "the image from earlier." With several similar names, the wrong file can get opened.

I got stuck at step one: the photo wasn't in the list. I copied it into the connected folder in Finder, asked again by file name, and the work went through immediately. My three re-pastes had all been walking the same path back and forth.

Ask for an export that never overwrites the original

Once images go through the folder, the next thing to protect is the original. If you just say "crop this," the result might be saved under the same name. Losing the original of someone's artwork is not something you can undo.

So rather than describing the processing in words, I hand Cowork a short script and ask it to run it. The script solves three things: crop from the center to the target ratio, scale down to a set width, and always write to a separate folder.

from pathlib import Path
from PIL import Image
 
SRC_DIR = Path("images")          # originals inside the connected folder
OUT_DIR = Path("images/_out")     # export destination, kept separate
TARGET_RATIO = 16 / 9
TARGET_WIDTH = 1920
 
def crop_center(img, ratio):
    w, h = img.size
    if w / h > ratio:             # too wide -> trim left and right
        new_w = int(h * ratio)
        left = (w - new_w) // 2
        return img.crop((left, 0, left + new_w, h))
    new_h = int(w / ratio)        # too tall -> trim top and bottom
    top = (h - new_h) // 2
    return img.crop((0, top, w, top + new_h))
 
def main():
    files = sorted(p for p in SRC_DIR.iterdir()
                   if p.suffix.lower() in {".jpg", ".jpeg", ".png"})
    if not files:
        raise SystemExit(f"No images found in: {SRC_DIR.resolve()}")
    OUT_DIR.mkdir(parents=True, exist_ok=True)
    for src in files:
        dst = OUT_DIR / f"{src.stem}_16x9{src.suffix.lower()}"
        if dst.exists():
            print(f"skip (already exists): {dst.name}")
            continue
        with Image.open(src) as img:
            out = crop_center(img.convert("RGB"), TARGET_RATIO)
            if out.width > TARGET_WIDTH:
                h = round(TARGET_WIDTH / TARGET_RATIO)
                out = out.resize((TARGET_WIDTH, h), Image.LANCZOS)
            out.save(dst, quality=92)
        print(f"{src.name} -> {dst.name} {out.size}")
 
if __name__ == "__main__":
    main()

Why it's written this way: if there are no images, it stops in the first few lines with a path in the error, so the very first stumble shows up as something concrete instead of a vague reply. Writing to _out and skipping files that already exist means you can run it as many times as you like without touching the originals or the previous results. And the last line prints the original name next to the exported size, so you can sanity-check the numbers before opening anything.

The request itself can be as simple as: "I've put the photos in the images folder. Please run this script and show me the output." Claude reads the script before running it, which takes away most of the worry about what's about to happen to your files.

Draw a line before handing over color and texture

I learned one more thing that same day. Along with the crop, I asked for the photo to be "a little brighter, with the colors tidied up." The sky's gradient came back with visible banding, and the texture of the artwork turned into something else entirely.

Automatic correction can produce a photo that looks plausible, but it doesn't know the colors the artist intended — and with a client's work, that matters even more. I ended up re-correcting that one image by hand from the original, and asked Cowork again for the crop and resize only.

Cowork shapes the image; I decide the color. That's the line I work by now. Ratio, size, format, file names — anything with a numeric right answer — I hand over. Color, skin texture, the feel of old paper — anything that needs a human eye — stays with me. Simply not mixing the two in one request has removed almost all of my redo work. As an indie developer handling batches of store images, I find this line matters more the more images there are.

Try your first run like this

If you haven't handled images in Cowork yet, I'd suggest starting with these small steps:

1. Create one working folder, add an images folder inside it, and connect it.
2. Copy a single image you want to edit into images (keep the original somewhere else).
3. Ask, "Please list what's in images," and confirm the file name appears.
4. Hand over the script above, have it run, and open the result in _out with your own eyes.

Once one image works, all that changes is how many you put in images. Paste into the chat when you want to talk something over; put it in the folder when you want it finished. Once that habit sets in, working with Cowork feels noticeably different.

If you later want to run batch image jobs every morning on a schedule and still be able to verify the results afterward, I go deeper into that design, with examples from my own setup, in the premium articles.