Background Remover

Turn an uploaded photo into a clean cutout on a transparent background.

involved Media & Video

What it adds

A processing step that separates the subject of an uploaded photo from its background and stores the result as a cutout with transparency.

What your agent is told to do

1
Run removal as a queued background job on the app's existing job infrastructure, and reuse the existing job progress reporting rather than blocking the upload request while the image is processed.
2
Write the result in a format that carries an alpha channel. Saving a cutout as JPEG silently fills the transparency with white and destroys the entire point of the feature.
3
Cap the input before processing: enforce a maximum resolution and file size server-side, and downscale oversized images to a working resolution rather than letting a single enormous photo exhaust memory.
4
Keep the original untouched alongside the cutout so the user can revert, retry with different settings, or use the full photo elsewhere.
5
Do not present a failed or poor separation as a finished result. When confidence is low or no subject is found, say so plainly, return the original, and offer manual touch-up instead of shipping a mangled cutout.

Edge cases it handles

Removal takes seconds to minutes depending on image size. Queue the work, return immediately, and show progress on the asset, so the upload form is never held open waiting for a result.
The output must be written in a format that supports alpha. Any pipeline step that re-encodes or flattens the image afterwards, including a thumbnail generator or an optimisation pass, must be checked for the same trap.
Some photos have no clear subject, or several. When the model cannot find one confidently, tell the user, keep the original, and do not present the best guess as a clean cutout.
An unbounded input will exhaust memory or run for minutes. Reject files above a server-side size limit and downscale beyond a maximum working resolution before processing, then scale the mask back up.
Hair, fur, and thin edges are where automatic removal fails visibly. Provide a brush that adds and removes from the mask so the user can repair the edges, with undo, rather than forcing a retry.
Processing costs money or compute. Meter it against the app's existing usage quotas, and make the limit visible before the user starts a batch rather than failing partway through.
A transparent cutout is invisible against a white page. Preview it over a checkerboard so the user can see what they actually got.
A job that fails or times out must leave the original asset intact and retryable, not a half-written file in the library.

Definition of done

Removal runs as a queued job with visible progress and never blocks the upload.
Output is written in a format preserving transparency, and no later pipeline step flattens it.
Oversized inputs are rejected or downscaled before processing, with limits enforced server-side.
The original image is retained and the user can revert.
Low-confidence results are reported honestly rather than presented as finished.
A manual brush with undo is available for repairing edges.
Failed jobs leave the asset intact and retryable.
The feature matches the existing design system.
No existing functionality is broken.

Related features

Picture-in-Picture Mode

Audio Waveform Scrubber

Hover Video Preview

How it works

1

Copy the link

Grab the Markdown instruction URL for this feature.
2

Give it to your AI

Paste it into Claude Code, Cursor, v0, Lovable — whatever you build with.
3

It inspects, then implements

Your agent reads your existing app first, then adds the feature to fit it.

Works with your stack

These instructions are written to adapt. They tell the agent to detect your framework, match your existing design system, and reuse what you already have — rather than assuming a particular stack.

Need it tighter than that? Customize the feature and tell it exactly what you're running.