Inspiration
Virtual try-on has become remarkably good at answering:
“Will this look good on me?”
But looking good in a generated image does not necessarily mean a garment belongs in someone’s wardrobe.
A shopper may buy a jacket that looks fantastic, only to discover that it duplicates something they already own, matches very few outfits, does not suit their climate, or works for only one occasion. The result may be another return—or another expensive item that is barely worn.
We built WorthWearing to answer the decision that comes after virtual try-on:
“Will I actually wear and keep this?”
WorthWearing combines Perfect Corp’s AI Clothes Virtual Try-On with explainable wardrobe intelligence, helping shoppers judge not only how a garment looks, but whether it deserves a place in their wardrobe.
What it does
WorthWearing is a B2B2C decision layer that fashion retailers could embed directly into a product page.
A shopper selects a garment and WorthWearing:
- Uses Perfect Corp’s AI Clothes Virtual Try-On API to visualize the product on the shopper.
- Compares the candidate with garments already in their wardrobe.
- Detects whether it duplicates an existing item.
- Generates outfits using compatible tops, bottoms, shoes and layers.
- Evaluates whether the item suits the shopper’s climate and real-life occasions.
- Calculates a transparent Worth Score, Wardrobe Compatibility score, and Return Risk proxy.
- Produces a recommendation: Worth It, Think Again, or Skip It.
- Shows an estimated twelve-month cost-per-wear scenario.
The important distinction is that visual appeal and wardrobe utility are different signals. WorthWearing brings both into one shopping decision.
A tale of two jackets
Our demo follows Maya Chen, a shopper in Portland with a curated twelve-item wardrobe.
First, Maya considers the Noir Moto Jacket.
Perfect Corp generates a virtual try-on showing that the jacket looks great on her. However, WorthWearing discovers that Maya already owns a highly similar leather biker jacket. The candidate also supports a narrow range of occasions and produces few new outfit combinations.
The result is Skip It.
Maya then considers the Harbor Field Jacket.
The same process shows that this jacket complements garments she already owns and creates combinations for work, weekends and rainy commutes. It has broader occasion coverage, lower duplication and stronger wardrobe compatibility.
The result changes to Worth It.
Both jackets can look good. Only one creates meaningful new value inside Maya’s wardrobe.
How we used Perfect Corp
Perfect Corp provides the visual foundation of the experience.
WorthWearing keeps the API key securely on the server and uses Perfect Corp’s File API to upload the shopper and garment images. It then creates a cloth-v4 virtual try-on task and polls the task until the generated image becomes available.
The application includes:
- Server-side credential management
- Image upload through the File API
- Asynchronous task creation and status polling
- Retry handling for transient API errors
- Timeout handling
- Explicit provider-status labels
- A clearly labelled prepared fallback if a live request cannot finish
The fallback is never silently presented as a live API response.
Perfect Corp answers “Can I see myself wearing this?” WorthWearing turns that visual experience into an explainable ownership decision.
How we built it
The judges’ experience is implemented as a single Streamlit application with a Python backend.
Streamlit interface
|
+-- Perfect Corp provider
| +-- File API upload
| +-- cloth-v4 task
| +-- status polling
|
+-- Wardrobe intelligence
+-- duplication analysis
+-- outfit generation
+-- climate compatibility
+-- occasion coverage
+-- cost-per-wear scenario
Every wardrobe item contains structured metadata covering category, subcategory, colors, style, season, occasion and layering position.
Compatible outfits are generated using explicit rules for:
- Color compatibility
- Style compatibility
- Season overlap
- Occasion overlap
- Layering order
The current Return Risk proxy uses five transparent components:
- (D): duplication
- (I): style isolation
- (C): climate mismatch
- (O): occasion narrowness
- (U): usage uncertainty
$$ \text{Return Risk} = \operatorname{round}\left( 100(0.30D + 0.25I + 0.20C + 0.15O + 0.10U) \right) $$
The interface shows every factor, weight, contribution, supporting garment and rejected outfit combination. The factor contributions reconcile directly with the displayed score.
We also added automated tests for scoring thresholds, outfit generation, provider behaviour, malformed inputs and API responses.
Challenges we faced
Connecting visual AI to a real decision
A virtual try-on image is visually compelling, but an image alone does not reveal whether a garment works with the shopper’s existing life. We had to create a structured bridge between Perfect Corp’s visual output and wardrobe-level evidence.
Making recommendations explainable
It would have been easy to ask a language model to output “buy” or “skip.” That would also make the result difficult to audit or reproduce.
Instead, we built a deterministic scoring system where every point can be traced to an explicit rule. Generative AI performs the task where it is strongest—visualization—while deterministic logic handles the decision that needs to be explained.
Handling external API latency safely
AI image generation is asynchronous and may encounter transient failures or timeouts. We implemented uploads, polling, retries and clear failure states. If the live call fails, the shopper chooses whether to use a prepared result; the application never swaps one in silently.
Avoiding unsupported claims
This prototype does not claim that it has already reduced returns or accurately predicted future cost per wear. Its scores are based on curated wardrobe metadata and explicit rules.
A production pilot would calibrate the scoring system against real retailer purchase, keep and return outcomes.
What we learned
We learned that the most valuable extension of virtual try-on may not be another visual effect. It may be a trustworthy decision layer built around the visualization.
We also learned that personalization becomes more meaningful when it uses what the shopper already owns. Instead of recommending products only because they are similar to previous purchases, WorthWearing asks whether a product adds something genuinely useful.
Finally, explainability can be part of the consumer experience rather than a hidden technical report. Showing the duplicate garment, compatible outfits and score contributions makes the recommendation easier to understand and challenge.
Retail and consumer value
For shoppers, WorthWearing can reduce uncertainty and help distinguish an exciting purchase from a useful purchase.
For retailers, it could become an embeddable product-page feature that provides new first-party signals about:
- Wardrobe compatibility
- Reasons for product hesitation
- Unmet wardrobe needs
- Intended occasions
- Recommendation acceptance
- Purchase and keep behaviour
A retailer pilot could compare purchasing, keeping and returning behaviour across recommendation bands. With sufficient outcome data, the weights and thresholds could be calibrated by garment category, market and customer segment.
The commercial model could combine a retailer platform fee with usage-based pricing for each completed try-on and wardrobe analysis.
What’s next
The next version of WorthWearing would add:
- Shopper-created wardrobe uploads
- Automated garment tagging
- Retailer catalogue integration
- Saved outfits and wardrobe gaps
- Category-specific scoring models
- Consent-based purchase and return feedback
- Calibration against real retailer outcomes
- An embeddable product-page SDK
Our goal is not to discourage shopping. It is to make every purchase more intentional, explainable and useful.
Virtual try-on shows whether it looks good. WorthWearing shows whether it deserves a place in your wardrobe.
We don’t help shoppers buy more. We help them keep what they buy.
Built With
- aiclothes
- computer-vision
- explainable-ai
- fashion-tech
- fastapi
- httpx
- machine-learning
- perfect-corp
- perfectcorp
- pydantic
- python
- recommender-system
- rest-api
- streamlit
- virtual-try
Log in or sign up for Devpost to join the conversation.