Overview
- Ciceroni, a curated marketplace for emerging Indian fashion and lifestyle labels, needed a faster way to publish designer catalogs.
- Each designer line sheet had to be converted into structured product attributes, shopper-friendly descriptions and clean catalog data.
- Musikaar built an AI-assisted pipeline that parses line sheets, enriches metadata with domain-aware AI, and outputs JSON close to Shopify import readiness.
- The prototype moved from setup to an end-to-end working workflow in roughly two development sessions.
- Once the prototype was ready, after thorough testing, the automated pipeline was deployed in production using cloud hosted containers.
- The important lesson was not simply "use AI." The value came from combining AI-assisted engineering speed with domain context, operational understanding, and human judgment.
Context
Musikaar works with businesses to understand core workflows and identify opportunities for meaningful automation. In this case, the workflow belonged to Ciceroni, a curated e-commerce destination for shoppers looking for distinctive, design-led products.
Ciceroni has grown into a curated marketplace for emerging fashion and lifestyle labels. It features about hundred designers on its platform.
As the catalog grew, one operational challenge became increasingly clear: designer onboarding did not scale easily.
Every new designer collection arrived with a line sheet and a set of product assets. Before those products could become store-ready, the team needed to transform that raw material into clean product information:
- Structured product attributes.
- Shopper-friendly titles and descriptions.
- Catalog data that could move toward Shopify import.
- Metadata that reflected fashion context, not generic product copy.
This was careful work. It needed accuracy, context, and sensitivity to how shoppers discover products online.
The Challenge
At first glance, the workflow looked like a straightforward automation problem: read a spreadsheet, map columns to product fields, and generate structured output.
The real workflow was more nuanced.
Every designer had their own format for their collection line sheet. The product metadata needed domain understanding. For Indian fashion and lifestyle products, useful catalog enrichment depends on context around fabrics, silhouettes, embroidery styles, occasions, and regional terminology. Generic AI-generated copy might sound fluent, but still miss what matters to shoppers and merchandisers.
Finally, the automation had to be practical. The pipeline was not expected to run at massive scale every day. A realistic usage pattern was closer to a few designer onboarding runs per month, so model choices, infrastructure complexity, and cost had to match the actual workload.
What We Built
Musikaar built a working pipeline that can take a designer line sheet, then produce clean, AI-enriched catalog data close to Shopify import readiness.
It could:
- Parse designer line sheets into structured product records.
- Enrich product descriptions and attributes using an LLM.
- Add domain context for fashion terminology, fabrics, silhouettes, occasions, and embroidery styles.
- Produce clean JSON output suitable for a future Shopify import workflow.
The goal was not to remove human judgment from catalog operations. The goal was to reduce repetitive transformation work and give the team a cleaner, more complete starting point for review.
Why Domain Context Mattered
The most important part of the system was not simply that it used an LLM.
In early testing, generic model output was not always precise enough for specialized fashion catalog data. The system needed to understand terms that are common in South Asian fashion but underrepresented in generic product datasets.
To improve the output, the pipeline added a local terminology and style knowledge layer. Before generating or assigning certain attributes, the model could reference context for fabrics, embroideries, traditional silhouettes, and occasion-based styling.
That changed the quality bar. The automation was no longer just filling empty fields. It was producing product information that better matched the way Ciceroni's shoppers discover and evaluate design-led products.
How AI-Assisted Engineering Accelerated the Work
This project was also a practical test of AI-assisted engineering.
Claude Code helped accelerate scaffolding, planning, parsing logic, image processing, LLM enrichment, queue handling, and prototype development. The implementation was built in phases rather than generated in one large pass.
The first phase established the data foundation:
- Project setup and environment configuration.
- Product data models.
- Initial line sheet parsing.
- Validation checks for field extraction and mapping.
- Early scoping for LLM-enriched attributes.
The enrichment phase added LLM-generated product metadata, supported by a domain-aware terminology layer.
AI made these steps faster, but it did not replace product judgment. Human guidance was still needed to define the workflow, challenge assumptions, choose appropriate infrastructure, account for messy inputs, and decide where review should remain in the process.
Engineering Decisions Behind the System
Several practical decisions shaped the system.
First, the pipeline treated designer line sheet as real-world inputs, not clean demo data.
Second, model infrastructure was chosen around expected usage. Since the workflow would likely run only a few times per month, an open-source model served through a vLLM endpoint was a better fit than defaulting to the most expensive commercial model.
Third, dependency choices were reviewed deliberately. When an LLM-related package carried supply chain concerns, the implementation moved to a safer custom wrapper.
Fourth, reliability concerns were handled as they appeared. When rate limits affected image classification and text generation, the system added queue and backoff behavior.
These decisions are where AI-assisted engineering differs from one-shot "vibe coding." The assistant helped move quickly, but engineering judgment kept the system aligned with the actual business workflow.
Results
In roughly two development sessions, the project moved from repository setup to an end-to-end working prototype.
The working pipeline could accept a line sheet and parse product data filter out non-product references, enrich product descriptions and attributes with domain-aware AI, and generate clean JSON close to Shopify import readiness.
We did thorough testing and made it production-ready. It was deployed in production using cloud hosted containers.
This was integrated with Shopify where a human can inspect generated product data before publishing it to the platform.
What Made the Difference
The speed was meaningful, but speed alone was not the point.
The project worked because AI-assisted development was paired with operational understanding:
- Recognizing that designer onboarding was the bottleneck, not just spreadsheet parsing.
- Accounting for how designers actually share assets.
- Adding fashion context so the output was more useful than generic AI copy.
- Choosing infrastructure and costs that matched the expected usage pattern.
- Preserving a human review step before catalog data becomes publishable.
This is the real promise of AI-assisted engineering: not replacing product judgment, but compressing the path from operational bottleneck to usable workflow.
Transferable Lessons
- Start with the workflow, not the AI tool. The right automation target was designer onboarding, a clear operational bottleneck.
- Design for messy inputs. Real product data lives across spreadsheets, folders, naming conventions, and human habits.
- Bring domain knowledge into the system. Specialized industries need context that generic model output often lacks.
- Use AI assistants to accelerate engineering phases, not skip them. Planning, review, validation, and security decisions still matter.
- Match infrastructure to usage. A workflow that runs a few times per month does not need the same architecture as a high-volume production service.
Conclusion
Ciceroni's designer onboarding workflow showed where AI-assisted engineering can create practical value.
The pipeline did not succeed because AI generated a quick demo. It succeeded because the team understood the operational problem, shaped the system around real catalog inputs, added domain context, and used AI to accelerate the build.
The designer onboarding time got reduced by 75% which is a significant saving.
For businesses, that is the useful pattern: identify a workflow that limits scale, bring domain knowledge to the automation, and use AI-assisted engineering to move from bottleneck to working prototype faster.
