convez.ai
SkillDesign & UIIntermediário
hamedarabuk

Jewellery Design Studio

hamedarabuk/jewellery-design-studio

Transforme referências de luxo em designs originais com IP seguro

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill Claude para designers de joias finas que transforma referências de casas de luxo em designs originais e seguros legalmente. Automatiza análise de DNA visual, geração de briefs, renderizações via gpt-image-2, fluxo de aprovação e arquivamento organizado por marca.

Instalação

$npx convez-ai hamedarabuk/jewellery-design-studio

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Gerar designs de joias derivados de referências de alto padrão mantendo originalidade
  • Criar biblioteca de peças aprovadas organizadas por marca e tier de joalharia
  • Automatizar fluxo de aprovação com renderizações e validação IP-safe

Veredito

Solução bem estruturada para o nicho específico de joalheiros de luxo. Combina análise visual, geração criativa e governance de IP de forma integrada, com workflow claro e arquivos organizados. Requer investimento em API (OpenAI) e ajuste fino da foundation de marca para cada designer.

README

A tradução para o português deste README ainda está na fila.

Jewellery Design Studio

A Claude Code skill repository for fine and high jewellery designers. Send a reference image from a luxury house (Harry Winston, Boucheron, Cartier, Tiffany, Graff), and Claude produces an original, IP-safe derived design in your brand's voice. Renders, brief, approval workflow, all in one folder per piece.

Built on the same pattern as youtube-channel-studio: a public template + per-brand foundation gitignored so your personal brand data never ships in the public repo.

What you get

Two skills:

  1. brand-init - a one-time interview that captures your brand identity (palette, motifs, naming conventions, IP rules). Writes brands/<brand-slug>/foundation.md. Run once per brand.

  2. design-from-reference - the workhorse. Send a reference image, get a derived piece with reference DNA analysis, design brief, hero render via gpt-image-2, iteration loop, approval, and on-model render. Files land at brands/<brand-slug>/proposed/<piece-slug>/ and graduate to brands/<brand-slug>/approved/<NN>-<piece-slug>/ on approval.

The IP-safe transformation rule is enforced at brief-writing time: every derived piece must change motif content + framing device + cultural anchor relative to its reference. The richness level (pavé density, multi-cut arrangement, mixed-metal palette) is preserved. The "would this be confused with the reference" check has to be answered explicitly.

Install

# Clone the repo
git clone https://github.com/<your-username>/jewellery-design-studio.git
cd jewellery-design-studio

# Set up Python (3.11+)
python -m venv .venv
.venv\Scripts\activate            # Windows
# or: source .venv/bin/activate    # macOS / Linux

pip install -r requirements.txt

# Set your API keys
cp .env.example .env
# Edit .env: add OPENAI_API_KEY (required) and Telegram bot token (optional)

You need an OpenAI API key for gpt-image-2: https://platform.openai.com/api-keys

Telegram is optional. Without it, renders are saved to disk and you review them via file explorer. With it, every render is delivered to your Telegram chat with a captioned approval prompt. To set up: message @BotFather, create a bot, get the token; then message your new bot once and read your chat id from https://api.telegram.org/bot<TOKEN>/getUpdates.

First-run walkthrough

Open the repo in Claude Code. Then:

1. Set up your brand foundation (one-time per brand)

> invoke the brand-init skill, brand slug "my-brand-2026"

Claude conducts a short interview: designer identity, partner brand (if licensing), catalogue tiers, design language, stone palette (allowed and banned), metal palette, naming convention, cultural anchor, IP-safe transformation rule, render defaults.

When the interview is done, brands/my-brand-2026/foundation.md is your durable brand identity. You never re-supply this information.

2. Design a piece from a reference

> design from this reference [attach reference image]
  brand=my-brand-2026, tier=high-jewellery

The skill:

  1. Saves the reference to brands/my-brand-2026/proposed/<slug>/reference-source.png.
  2. Writes reference.md with a DNA analysis (what makes the reference expensive; what to take; what to change).
  3. Writes brief.md with the derived piece (name, design intent, materials, retail, lead time, "what makes this not a clone" section).
  4. Renders the front view via gpt-image-2 high quality at 1536x2048.
  5. Sends a Telegram preview (or prints the file path) and asks for approval.

3. Iterate or approve

You can:

  • Approve as-is: skill graduates the piece to approved/<NN>-<slug>/ and renders the on-model shot at 2400x3200 using the front render as a consistency reference. Updates approved/INDEX.md.
  • Iterate with notes: "make the central rose smaller", "both feet on the branch", "white chain not yellow". The skill re-renders via gpt-image-2 edit using the current render as reference.
  • Render variations: useful when there is a binary choice (chain colour, pose, framing). The skill produces 2-4 variations and builds a 2x2 collage so you can pick.
  • Reject and start over: the proposed folder is archived; you can send a new reference image.

4. Send the next reference

Once a piece is approved, send the next reference image. The skill writes the next position number into approved/INDEX.md automatically.

File layout per brand

brands/<brand-slug>/
├── foundation.md                       # your brand identity (gitignored)
├── brand.json                          # optional structured mirror of foundation
├── subjects/                           # optional: named ambassadors (locked faces)
│   └── <ambassador>/                   #   master.png + angle/hand refs + PROFILE.md
├── collections/                        # optional: <collection>.json (motifs, palette)
├── proposed/                           # iteration working folder
│   └── <piece-slug>/
│       ├── reference-source.png        # the reference you sent
│       ├── reference.md                # DNA analysis
│       ├── brief.md                    # proposed design
│       ├── render-v1.png               # first iteration
│       ├── render-v1-tg.jpg            # Telegram preview
│       ├── render-v2-<note>.png        # subsequent iterations
│       └── comparison-collage.png      # if variations were rendered
└── approved/
    ├── INDEX.md                        # ordered table of locked pieces
    └── <NN>-<piece-slug>/
        ├── reference.md
        ├── brief.md                    # status=APPROVED
        ├── manifest.json
        ├── render-front.png            # locked hero
        ├── render-on-model.png         # editorial portrait
        └── render-on-model-tg.jpg

Ambassadors and collections (optional per-brand enrichment)

A brand can carry two optional folders that make the skill richer. Both live under the gitignored brands/<slug>/, so they stay private to your clone.

Ambassadors (subjects/): named models with a locked likeness. Each subjects/<id>/ holds a master.png (the likeness reference), angle and hand references, and a PROFILE.md (casting: age, features, wardrobe, the styles they suit). When a brand has a roster, the on-model step uses a named ambassador for a consistent face across the whole catalogue, rather than a fresh generic model each time. With no roster, the skill falls back to a generic model from the foundation. Build a roster by generating a master per ambassador, then each angle from that master (the star pattern: every angle references the master, never a chain of generations).

Collections (collections/): structured <id>.json files (motifs, palette, signature pieces, design notes). Name a collection when designing and its language flows into the brief and the render prompt, so the piece sits inside that collection's world. Optional; the default designs against the foundation alone.

Shared styles (styles/): photography registers (studio editorial, documentary portrait, product catalogue) that any brand uses. These ship with the skill, unlike per-brand data.

Source of truth and sync

The maintainer keeps the canonical grammar, styles, ambassadors, and collections in one place and syncs them into this repo with python scripts/sync_from_source.py (--dry-run to preview). The styles/ and docs/ content ships; per-brand data refreshes the local clone only, because brands/ is gitignored. If you are cloning this skill for your own brand, ignore the sync and populate your own brands/<slug>/ via brand-init plus the optional folders above.

Image quality

The quality bar for this repo is editorial campaign: Calvin Klein, Aesop, COS. Not jewellery catalogue.

Provider routing:

  • gpt-image-2 (OpenAI, scripts/gpt_image_client.py) is the primary generator for every render in this skill: front product, on-model, scene, ambassador, plus any render with overlay typography. Apply the seven prompt levers from the grammar doc regardless of subject.
  • Nano Banana (Google Gemini 3 Pro Image, scripts/nano_banana_client.py) is a fallback. Reach for it only when a specific gpt-image-2 render misses on a measurable dimension (pore detail on a tight hand shot, fine fabric weave, hand anatomy fidelity) and a re-prompt does not recover. Document the reason in brief.md when you fall back.

Grammar reference: docs/luxury-studio-grammar.md documents the seven prompt levers (subject framing, lens character, lighting, wardrobe/casting/skin, backdrop, post-grading, focal hierarchy) with worked before/after examples. Read it before writing any prompt.

Starting point for on-model renders: templates/on-model-prompt-template.md provides a fill-in-the-slots template with the locked grammar block pre-included. Fill the six slots (subject, wardrobe, pose, piece, placement, backdrop) and run; do not delete the locked grammar.

OPENAI_API_KEY is required. Set GEMINI_API_KEY in .env only if you plan to use the Nano Banana fallback.

Cost expectations

Per approved piece (front product render + on-model + 1-2 iterations):

  • gpt-image-2 high quality at 1536x2048 (front render): ~$0.50 - $1.00 per render
  • gpt-image-2 high quality at 1280x1600 (on-model edit): ~$0.40 - $0.80 per render
  • Nano Banana at 4:5 1280x1600 (fallback only): ~$0.04 per render
  • Typical total per approved piece: $2 - $5

Per-session soft cap: $10 of render charges. The skill flags when you approach this.

AI metadata stripping (no "Made with AI" badges)

Every image written by gpt_image_client.py runs through scripts/lib/image_io.py:strip_metadata immediately after generation. The strip rebuilds the image from raw pixel data into a fresh Pillow Image, guaranteeing that no ancillary chunks (C2PA, ContentCredentials, XMP, EXIF, OpenAI / gpt-image-2 software tags) survive.

This matters because LinkedIn, Instagram, X, and other social platforms read these tags and display a visible "Made with AI" badge on posts that carry them. Stripping is automatic and unconditional in this skill.

Note: SynthID is a pixel-level watermark embedded by Google's image models (Gemini, Imagen, Nano Banana) into the actual image pixels. It cannot be removed by metadata stripping and is left intact. OpenAI's gpt-image-2 does not embed SynthID, so renders from this skill's default generator are clean.

Verify any image yourself:

python scripts/design_workflow.py verify-clean --path brands/<brand>/approved/<NN>-<slug>/render-front.png

Exit code 0 if clean, 1 if any AI-generator signature is still present. Pass --json for a structured report.

Telegram approval (optional)

Without Telegram the workflow still runs: renders are saved to disk and you review them via file explorer, approving in the Claude Code chat. With Telegram every render lands in your phone with three one-tap buttons: Approve, Iterate, Reject.

Hard warning: use a dedicated bot token. Telegram getUpdates is single-consumer. If you reuse a token already polled by another service (an existing notification bot, another skill poller, etc.), that service will consume the approval callbacks and the studio poller will time out silently. Create a fresh bot in BotFather specifically for this studio.

Setup wizard (recommended)

Run the interactive wizard. It walks you through BotFather, validates your token, detects your chat id automatically, and writes both values to .env in one step:

python scripts/telegram_setup.py

The wizard backs up your existing .env before making changes, and sends a confirmation message to your chat when done. Run it again any time to reconfigure.

To verify your setup later without re-running the full wizard:

python scripts/telegram_setup.py --check

Exit code 0 means the token is valid and the studio can reach your chat.

Verify the approval-flow wiring

After setup, confirm that the approval keyboard is wired correctly with a dry run (no API call, no image needed):

python scripts/telegram_approval.py send \
  --piece brands/my-brand/proposed/albion-garland \
  --image brands/my-brand/proposed/albion-garland/render-v1-tg.jpg \
  --caption "Dry run test" \
  --dry-run

The printed JSON shows the inline_keyboard array with three buttons and the jds:<action>:<id> callback_data shape.

  1. Message @BotFather on Telegram. Send /newbot and follow the prompts. Copy the bot token (format 123456789:ABCdef...).
  2. Start a chat with your new bot by searching for its username and sending any message.
  3. Visit https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates in your browser. Find your chat id in the JSON (result[0].message.chat.id).
  4. Add both values to your .env:
TELEGRAM_BOT_TOKEN=123456789:ABCdef...
TELEGRAM_CHAT_ID=749526661

Manual approval test (live API)

Send a render and poll for a button tap:

# Terminal 1: send
python scripts/telegram_approval.py send \
  --piece brands/my-brand/proposed/albion-garland \
  --image brands/my-brand/proposed/albion-garland/render-v1-tg.jpg \
  --caption "Test send from jewellery-design-studio"

# Terminal 2: poll (run immediately after; 60-second timeout for a quick test)
python scripts/telegram_approval.py poll \
  --piece brands/my-brand/proposed/albion-garland \
  --timeout 60

Tap a button in Telegram. The poller prints the verdict JSON and exits.


How to customise

Edit brands/<brand-slug>/foundation.md directly to refine your brand voice. The design-from-reference skill reads it on every invocation, so changes take effect immediately.

Edit .claude/skills/design-from-reference/SKILL.md to adjust the workflow (render sizes, iteration cap, Telegram caption format). Edits stay local to your clone; you can fork the repo and share your variant.

Licensing the studio for your students or team

The repo is MIT-licensed. You can:

  • Fork it for your own students or workshop participants.
  • Add your own custom skills (e.g. for studio quoting, GIA certificate generation, supplier price lookup).
  • Pre-populate brand foundations for your students so they start from a working example.

What this skill is NOT

  • It is not a CAD program. It produces editorial renders, not Rhino or MatrixGold files. Use it for pitch artefacts, catalogue images, and design exploration. Bring renders to your CAD jeweller separately.
  • It is not a copy machine. The IP-safe transformation rule is the heart of the tool. Pieces that fail the "would this be confused with the reference" check are refused.
  • It is not a customer-facing site. The approved/ folder is your input. A separate microsite or catalogue tool reads approved/INDEX.md and manifest.json to build the customer-facing artefact.

Acknowledgements

Pattern inspired by youtube-channel-studio. Born out of the Mappin & Webb Collection 01 pitch (Hamed Arab Choobdar, independent designer, 2026).

Ver o original no GitHub

Bom para

Relacionados