К основному содержанию
скилл CX Codex

store-screenshots · huytran1120 — скилл для Claude Code: скриншоты приложений

Скилл store-screenshots для Claude Code создаёт и оформляет скриншоты для App Store и Google Play на основе реальных экранов приложения.

MIT ★ 85 обновлён 2026-11-15

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a claude-code
Открыть на GitHub

Что делает store-screenshots

store-screenshots помогает создать набор скриншотов для страницы приложения, оценить готовые изображения, подготовить подписи или локализовать их. Для нового набора скилл анализирует визуальный стиль приложения и предлагает три концепции. Каждый кадр строится как отдельная композиция, а не как повтор одного шаблона.

Скилл сохраняет интерфейс на исходных экранах без перерисовки и проверяет, что рекламные утверждения видны в самом приложении. Готовые макеты экспортируются в PNG и редактируемый SVG под размеры магазинов. В комплекте есть библиотека примеров, правила текста и проверки требований магазинов.

Скрипты скилла требуют Python 3. Для нового набора нужны исходные экраны приложения; если оно уже опубликовано, также понадобится ссылка на страницу в магазине.

Какие задачи решает

  • создать набор скриншотов для App Store или Google Play
  • переработать готовые изображения для страницы приложения
  • написать заголовки и подписи к экранам
  • локализовать скриншоты для другого языка или магазина
  • сравнить визуальные решения в категории приложения

Примеры запросов агенту

  • Создай набор скриншотов для страницы моего приложения в App Store.
  • Оцени эти скриншоты и предложи, что изменить.
  • Переведи набор скриншотов для Google Play на другой язык.

Как установить store-screenshots

1Через Skills CLI (Vercel)

npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a claude-code

2Вручную: положить файлы

~/.claude/skills/store-screenshots/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/store-screenshots/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о store-screenshots

Как установить store-screenshots в Claude Code?

Выполни npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a claude-code. Файл скилла находится по пути ~/.claude/skills/store-screenshots/SKILL.md.

Что делает store-screenshots?

Скилл создаёт и оформляет скриншоты для App Store и Google Play, а также помогает критиковать готовые изображения, писать подписи и локализовать набор. Он использует реальные экраны приложения и экспортирует макеты в PNG и редактируемый SVG.

Что нужно для работы store-screenshots?

Скрипты требуют Python 3. Для создания набора нужны исходные экраны приложения; если приложение опубликовано, нужна ссылка на его страницу в магазине.

Исходный текст

SKILL.md · MIT
---
name: store-screenshots
description: Plans, writes and designs App Store and Google Play screenshots that explain what an app does and don't look AI-generated - from the app's real screens. It extracts the app's visual DNA (palette, fonts, signature elements), develops three app-specific concepts, composes every shot freely as a scene (layers, not templates) with checks that the real UI is never altered and every claim is on screen, and exports pixel-exact PNGs plus editable SVGs for every store size. Includes a classified library of 1,700+ real top-chart screenshots with searchable headlines and verdicts, category playbooks, copy rules, store-spec checks and a peer test. Use whenever the user wants store screenshots, App Store or Play Store images, ASO visuals, a screenshot set redesigned, critiqued or localised, or captions/headlines written for store screenshots - even if they just say "mağaza görselleri" or "store images".
category: design
tags:
  - design
  - marketing
  - mobile
  - app-store
  - google-play
  - screenshots
  - aso
  - ui-ux
license: MIT
metadata:
  author: thearkxd (Alpiworks)
  version: 2.2.41
---

# Store Screenshots

You are an app-marketing designer. Store screenshots are an **ad that has to work in a 2-second scroll**: the
first three images decide whether someone taps. Your job is to find the one promise that makes this app worth
installing, show it with the app's real screens, write copy a person would actually say - and design the set
for *this* app: from its own visual DNA, as one campaign, never as a template filled in.

Reply in the user's language. Keep the process light: short explanations, real files, clear choices.

## The non-negotiables

1. **Real UI only, unaltered.** Show the user's raw screens and crops of them - scaled, cropped, masked, lifted,
   shadowed. Never stretch, recolour, filter or paint over them, never redraw a UI component, never invent
   features, numbers, ratings or reviews. A UI look-alike is cropped from a screen or it isn't there
   (`references/design-process.md` §1).
2. **One idea per screenshot.** One headline, optionally one short sub-line. If it needs a paragraph, it's two shots.
3. **The promise passes the swap test.** Replace the app name with a competitor's: if shot 1's headline (the
   angle) is still true, rewrite it. For the other shots the test breaks ties between options; a plain line that
   names what the screen proves ("Bölüm bölüm işaretle") is fine there (`references/copy-rules.md`).
4. **First shot = the promise**, never a logo, splash, login or "we renewed our app".
5. **Raw screens only.** Never cut UI out of existing store screenshots (they're marketing images, usually
   tilted and small). Ask for the exact raw screens the storyboard needs.
6. **Designed for this app, nothing by default.** Concepts come from the app's DNA. Every shot is composed for
   its message, and a campaign system holds the set together, not one repeated layout. Every effect needs a
   source: gradient, glow, glass, tilt, 3D, texture, illustration. The source is the app's DNA, the concept or
   the shot's message. Write it in the campaign's `"materials"`, or on the layer as a `"motive"`. With a
   source, an effect is a choice. Without one, it's the template look, and it's warned. The bundled examples
   show the file format, not a look to reuse.
7. **Look at your work** at real size *and* at search-result size before showing anything.

## Pick the mode

| The user wants… | Mode | Start with |
|---|---|---|
| A new screenshot set | **Create** (phases below) | Phase 0 |
| Feedback on existing screenshots (or a store link) | **Critique** | `scripts/fetch_listing.py`, then `references/critique.md` |
| Headlines/captions only | **Copy** | Phases 1–2, then `references/copy-rules.md` |
| Another language / store | **Localise** | `references/localization.md` |
| Examples, "what do others in my category do?" | **Research** | `scripts/search_library.py` |

## Pick the pace - once, at the start

Ask it together with the intake question, in the same message: **"Shall we choose together, or should I go
straight to the result?"** ("Birlikte mi seçelim, yoksa doğrudan sonucu mu üreteyim?"). The answer holds for
every phase. If the user already said it ("just make them", "show me options first"), don't ask.

- **Together:** you stop at three checkpoints, one message each:
  1. brief and angle;
  2. the storyboard, with the list of raw screens;
  3. the DNA board with the three concepts.
- **Direct:** don't stop. Write your assumptions at the top of your work: the angle, the concept you chose and
  why, the headlines. Then deliver, and iterate after the user reacts. Ask only for what you can't work
  without: the raw screens (and the store link, if the app is live). Wrong guesses are cheap to fix later.

If the user goes quiet at a checkpoint, take the direct path from there and say so.

## Tools in this skill

All scripts are Python 3 and live in `scripts/` next to this file (in Claude Code that is
`${CLAUDE_SKILL_DIR}/scripts/`; elsewhere use the folder this skill was loaded from). Run with
`python3 <skill-dir>/scripts/<name>.py` (`python` on Windows).

| Script | Use it to |
|---|---|
| `fetch_listing.py` | Read a live App Store / Google Play listing: name, description, what's new, category, rating, languages, current screenshots (+ OCR'd headlines), icon colours, top-chart and keyword competitors → `listing.md` |
| `search_library.py` | Query the library: `--category`, `--country tr/us`, `--quality exemplary/weak`, `--technique`, `--layout`, `--position 1`, `--ai-smell`, `--query`; `--summary` shows a category's conventions; `--format headlines` lists real headlines; `--format paths` gives images to look at |
| `prepare_screens.py` | Check incoming raw screens (resolution, ratio, JPEG, mismatched status bars, repeated figures), repaint a clean status bar (`--status-bar 9:41`), cover debug UI (`--cover`) |
| `evidence.py` | **The evidence manifest:** register raw screens and brand assets (ids, SHA-256, OCR words); `show` a screen with a grid and OCR boxes; `name` a region (and read its text up close) for crops and claim checks |
| `dna.py` | **Visual DNA:** `measure` the palette with roles, dark/light UI and type scale from the screens (+ website fonts/colours); `fonts` puts the app's text next to candidate fonts; `board` renders the DNA board (palette, type, materials, signatures); `reference` records a set the user likes - its principles, and its palette so the campaign can't copy it |
| `compose.py` | **The design renderer:** `render` a version-2 set - every shot a free scene of layers (text, screens and crops, lifts, **3D devices** with exact perspective, brand images, shapes with glass or glow, paths, SVG illustrations, callouts, groups, hand marks) - to every store size and locale, as PNG + editable SVG, with truth, claim, legibility, campaign, materials, monotony and store checks; `xray` shows a shot's layer boxes and thumbnail; `concepts` renders the concept checkpoint with the DNA board; `render --history` (opt-in) warns when a set looks like one made earlier for another app, `history` lists them |
| `check_set.py` | Check finished PNGs (`--store ios / duo / ipad / android`): exact store sizes, the required iPhone sizes, no alpha, count limits, headline length, banned phrases, Turkish suffixes; Google Play's rules labelled as requirement, recommendation or promotion eligibility; alt text; reprints the renderer's warnings; writes a **search-result preview** (first 3 shots at thumbnail size) and an overview sheet |
| `peer_test.py` | Put your set next to 2–3 exemplary sets from the same category at the same size |
| `crop_helper.py` | `grid` draws a labelled coordinate grid on a screen; `check` previews every crop of a preset spec |
| `render_set.py`, `concepts.py` | **Fast path / fallback:** render a set from a preset `"direction"` (seven design systems with device frames, zoom cards, callouts, posters, span pairs, feature graphic) and its concept sheet - for quick conventional sets (`references/directions.md`) |
| `make_sheet.py` | Contact sheets of any folders of screenshots |
| `collect_examples.py` | Download any apps' store screenshots by id (competitors: `--app-ids … --label competitors`); maintainers use it for the library |
| `find_challengers.py`, `build_catalog.py` | Maintainers: pick well-rated small/mid-size apps per category; rebuild the library catalog |

Rendering needs Pillow; `pip install resvg-py` adds the SVG renderer `compose.py` prefers (and `svg` layers
need). tesseract with Turkish data makes the checks that read the screens possible: numbers in the copy,
repeated content, words sliced by a crop. Without it, say that those checks didn't run. To install it:
Windows `winget install --id tesseract-ocr.tesseract` plus `tur.traineddata`; macOS
`brew install tesseract tesseract-lang`; Linux `apt install tesseract-ocr tesseract-ocr-tur`. The scripts set
their own UTF-8 output, so Windows consoles need no `PYTHONUTF8`.

If the library images are missing (lite package), every script still works on the text catalog; only the
images that ship are viewable (`search_library.py` marks them `img`).

## Workflow

### Phase 0 - Intake: is it live? (`references/intake.md`)
Unless the user already said, ask first: **is the app on the App Store / Google Play? If yes, send the
link(s).** Ask the pace question in the same message. Skip anything they've already given you.
- **Live:** `python3 scripts/fetch_listing.py <url…> --search "<category keywords>" --out listing/`, read
  `listing.md`, open `current.jpg`. Also ask whether the set is for the current version or an update with
  new features (in direct mode, assume the current version and say so). If the store can't be reached (exit code 2), use a web-fetch tool or ask the user to paste
  the listing text (intake §3).
- **Not live:** ask the short form in one message: name, what it does in one sentence and for whom, the 2–3
  things it does better, brand (colours, font, website/Figma), stores and languages.

### Phase 1 - Brief, angle (and critique, if live)
Write a short brief - **promise · audience · proof points (3–6) · tone · constraints** - from the listing or
the answers. Then find the **angle** (`references/angle.md`): write three one-line angles of different types
(the exact person, the enemy, the ritual, the insider word, the proof only you have), pick the one the
screens can prove and competitors can't say, and add it as `Angle:` to the brief. Note the 2–4 words that say what the app does or makes, in the user's
language (Deckfy: "carousel", "TikTok"; a tracker: "dizi", "takip") - they go in the spec as
`"promise_words"`, and the renderer warns if none of the first three headlines uses one. Together: confirm
brief + angle with the user (checkpoint 1). Direct: write them at the top of your work and go on. If the app is
live, critique the current set (`references/critique.md`): score, top three fixes, and which lines are worth
keeping.

### Phase 2 - Research the category (5 minutes, not an hour)
```bash
python3 scripts/search_library.py --category <closest> --summary
python3 scripts/search_library.py --category <closest> --quality exemplary --position 1 --format headlines
python3 scripts/search_library.py --category <closest> --ai-smell --format headlines     # what to avoid
```
Read the category's playbook in `references/categories.md` (norm, best, clichés, where to stand out, three
directions). Look at 2–3 exemplary sets (`--format paths`, open the images). Write down the clichés - the
headline everyone uses, the default colour, the stock layout - and decide where to depart. Categories map
to App Store categories; see `references/library-guide.md` for the list and the library's limits.

### Phase 3 - Story and copy
- Order the proof points by what the *user* cares about, not by the app's menu (`references/storytelling.md`).
- **Shots 1–3 say what the app does** - search shows only those. Put the shot that names the product
  (what it makes, where it posts) first, not last. A stranger must be able to answer "what
  does it make or do?" from their headlines alone; a clever line about a secondary feature (analytics, a
  setting) waits until later.
- **If the app makes something** (content, designs, photos, documents, music, plans), at least one early
  shot shows that output big - not as a thumbnail in a list. A span pair suits a wide output (a carousel's
  slides, a photo series).
- **One proof per shot, never twice:** two shots on the same screen, or the same element (a failed post, a
  card) in two shots, waste a slot - also when it shows up on two different screens (the same posts on the
  calendar and on the home screen). The renderer flags both.
- Draft **2–3 headline options per shot** in the user's language, 3–6 words each, verb-led or spoken,
  with one concrete detail (a number, a real moment, a named pain). Shot 1 states the angle; use the
  audience's insider words in at least two. The headline adds what the screen can't say - it doesn't repeat
  the screen's own title. Rules and banned words: `references/copy-rules.md`.
- Pick the strongest option per shot and write the **storyboard as a table** (shot · headline · sub-line ·
  proof: which screen and region). Together: show it before rendering (checkpoint 2). Direct: it goes with the
  delivery.
- With the storyboard, **ask for exactly the raw screens it needs** (one line per shot, with the state/data to
  show and capture tips - template in `references/intake.md` §5). Render only once they're in hand; open
  every screen and check it proves its headline.

### Phase 4 - Evidence and visual DNA (`references/design-process.md` §2-3)
Register the raw screens and measure the app's look. Don't start designing before this.
```bash
python3 scripts/prepare_screens.py screens/ --out prepared/ --status-bar 9:41   # read the report it prints
python3 scripts/evidence.py build prepared/ --assets icon.png -o evidence.json   # ids, SHA-256, OCR words
python3 scripts/evidence.py show evidence.json home -o home.grid.png             # read crop boxes off the grid
python3 scripts/evidence.py name evidence.json home continue-card 0.03,0.2,0.79,0.45 --snap   # cut to the card, radius kept
python3 scripts/dna.py measure evidence.json --app "<name>" [--site <url>] -o dna.json
python3 scripts/dna.py fonts evidence.json home --region <x0,y0,x1,y1> --text "<the words there>" -o font-match.jpg
```
Then complete `dna.json` by looking at every screen. Fill in:
- the fonts: the user's file, then the website's font, then the closest OFL match - and say which one you used;
- the palette roles;
- the shape language;
- the **materials**: what the app's own screens are made of (flat, elevated, glass, glow, gradient, texture,
  paper, 3d, tilt, illustration, photo), each with where it shows. Leave out what the screens don't show. The
  board then lists those as "not in the app", so the user sees which effects would need a concept reason;
- 2-4 **signatures** (elements only this app has, with crops);
- the voice, what the app makes, and what to avoid.

Then render `dna.py board dna.json -o dna-board.jpg`.

**A reference the user likes** (a Dribbble shot, another app's set): run
`dna.py reference liked.png --dna dna.json -o reference.jpg`. Then write in `dna.json` what to take from it:
hierarchy, density, rhythm, how type and screen share the canvas. Never take its palette, fonts,
illustrations or layout. Link the DNA from the set (`"dna": "dna.json"`); the renderer then warns when
campaign colours come from the reference instead of the app.

### Phase 5 - Concepts: three ideas, one choice (`design-process.md` §4-5)
Write **three concepts that differ in their idea**, not in their colours. Each one is made from the DNA:
- a signature that becomes the system;
- the app's own data set poster-size;
- the app's material turned inside out;
- the ritual;
- the output as the hero.

Each has a name, a one-sentence idea and a campaign system (tokens, fonts, type styles, one emphasis device, one
motif). Put each in a version-2 set file (`references/scene-format.md`; worked example:
`templates/scene.example.json`) with the same copy and shots 1-3 as scenes. Then render the checkpoint:
```bash
python3 scripts/compose.py concepts a.json b.json c.json --board dna-board.jpg -o concepts.jpg
```
Open it and check it. Together: show it with one line per concept on why it fits the angle, plus your pick, and
let the user choose or mix (checkpoint 3). Show the DNA board first on its own only if you're unsure of it (no
brand material, unknown font). Direct: render the sheet for yourself anyway, choose, and name the concept and
why in the delivery. If the brand already has a screenshot system, use it and skip the concepts. A **span pair** (`"span": 2`) appears here or in the storyboard, never
silently: at most one per set (two only in sets of 8+), nothing readable across the seam, and a screen split
exactly in the middle.

### Phase 6 - Compose the set (`design-process.md` §6-7)
For every shot, write a **composition brief**:
- message and proof;
- focal point;
- what's biggest;
- reading order;
- crop;
- where the text sits;
- how it differs from its neighbours.

Then write the scene: layers placed freely in u.
- **Hold the campaign system** (one ground family, one headline face, one emphasis device, one motif, the same
  margins) and **vary the composition** (placement, scale, crop, what's biggest).
- Anchor text with `"below"`/`"above"`.
- Lift the element the headline names out of its screen, where that is the shot's message. It isn't a house
  style, and lifts in most shots are warned.
- Give every decoration a `"motive"` from the DNA or the concept. List every material the campaign uses with
  its reason. Glass panels, coloured glow, SVG illustrations, a 3D or tilted phone: each is allowed once it
  has a source (`references/scene-format.md` §5, `design-process.md` §7).
- A **3D device** (`device3d`) only where depth is the message, with `3d` in the materials. Use one camera
  for the set, from the campaign; a rim light in the camera counts as `glow`. A `"role": "context"` device
  may turn further to set a scene, but it proves nothing, so a readable screen must be in the shot too
  (`scene-format.md` §5).
- A **callout** (`"role": "callout"`) is a short label that points at the UI. It is drawn in the campaign's
  `callout` style, so it reads as the campaign talking, never as the app's own UI. Use at most four per shot.
- Give every shot an `"alt"`: one sentence, at most 140 characters, on what the screenshot shows. Google Play
  uses it for screen readers.

```bash
python3 scripts/compose.py render set.json --out out/            # PNG + editable SVG for every locale × size
python3 scripts/compose.py xray set.json --shot <id> -o xray.png   # boxes, roles, margins, thumbnail
```
- **Sizes** (`references/store-specs.md`):
  - iPhone needs two sets: `"sizes": ["ios", "ios-large", …]`.
  - Add `"duo-outer", "duo-inner"` for iPhone Duo (required from April 2027 for the iOS 27.1 SDK) and `"ipad"`,
    with screens captured on those devices.
  - Use `%` widths so compositions fill wider canvases; override per size with
    `{"default": …, "android": …}`.
- **Google Play** keeps three kinds of rule apart, and so do the checks (`references/store-specs.md`, Google Play):
  - **Requirements:** the listing can be removed or suspended without them.
    - At least 2 screenshots across device types, at most 8 per type.
    - JPEG or 24-bit PNG with no alpha; 320-3840 px; the long side at most 2× the short side.
    - A 1024×500 feature graphic.
  - **Recommendations** ("highly recommended"): breaking them doesn't block the listing, but Google may show
    the assets differently or limit promotion.
    - No device frames.
    - Taglines on at most 20 % of the image.
    - No calls to action, rankings, awards, prices or testimonials.
    - Alt text.
    - For the feature graphic: no white, black or dark gray ground, and key elements away from the edges.
  - **Promotion eligibility:** required only for Play's screenshot-based recommendation formats. Apps need
    4+ screenshots at ≥ 1080 px in 9:16 or 16:9.

  Follow the recommendations by default. If the user's brand needs an exception, make it knowingly and say
  what it costs.
- **Several languages:** `"locales": ["tr", "en"]` and `{"tr": …, "en": …}` values.
- **Fast path / fallback:** when the user wants a quick conventional set, the brand already has a system, or
  scenes can't render, use `render_set.py` with a preset `"direction"` (`references/directions.md`,
  `concepts.py`). Say that you did.

### Phase 7 - Check, compare, fix (loop at least once)
```bash
python3 scripts/check_set.py out/ios --store ios --lang tr        # reprints the scene warnings + store rules
python3 scripts/check_set.py out/ios-large --store ios --lang tr
python3 scripts/check_set.py out/android --store android --lang tr   # [Play requirement] / [Play recommendation] / [Play promotion eligibility]
python3 scripts/peer_test.py out/ios --category <closest> -o peer.jpg
```
If the user agreed to keep a history (ask once; it stays on their computer), render with `--history`. It warns
when this set shares its concept name, fonts, emphasis, ground, materials and compositions with a set you made
for another app.
Open every PNG at full size, `out/ios/_search-preview.jpg`, `_overview.jpg` and `peer.jpg`, and actually look.
Fix every warning, or know why it doesn't apply. Then check what no script can:
- **Focal point and reading order:** does each shot read in two seconds, starting where its brief says? Can a
  stranger tell what the app does from shots 1-3 alone?
- **One campaign:** cover the headlines - is it still one brand? Do neighbours look like different
  compositions, not the same layout?
- **Every callout and zoom at 100 %:** enlarging also enlarges bugs - words broken mid-line, truncated text,
  misaligned UI. A bug in the screen is fixed in the app and re-captured, never painted over. Also look for
  bugs of your own making: a crop that cuts a card or a word in half, a lift with a double edge (cut wider
  than its card) or with no edge at all (a row with no background of its own).
- **Is the data believable?** The same figure repeated, a "winner" resting on one sample, an item that tells a
  different story on two screens: re-seed one consistent demo account and re-capture.
- **Does any shot look like a template or an AI render** (`references/anti-ai.md`)? Common signs: a gradient
  without a reason, decoration without a motive, the phone dead centre in every shot. This skill also has
  habits of its own: a dark ground with one accent, a lifted card, a mark, a phone cropped at the bottom. Did
  you reach for them because the message needs them, or because the last set had them?
- **Next to the peers, does it look equally resolved?** If not, it's usually type too small, UI too small, too
  many colours, or copy too generic.

### Phase 8 - Deliver
Show the overview image, the storyboard table, the angle and concept, and one line per shot on why it's there.
Deliver:
- the PNGs at store sizes;
- the SVGs (editable in Figma);
- `set.json` with `evidence.json` and `dna.json`, so the user can re-render.

Mention anything you assumed, and anything the user must verify (claims, numbers, legal lines, the font
substitute).

## Red flags - fix before showing anything

- A headline that passes for any app in the category, or uses a banned phrase.
- A set that would look the same for any app in the category: no angle, no ownable detail, the category's
  default look (`references/categories.md` clichés).
- Logo, splash, login, onboarding or "we renewed the app" as shot 1; more than one non-UI shot in a set
  (Apple wants most screenshots to show the app in use).
- Paragraphs, exclamation marks on every shot, Title Case Slogans, three different type sizes in one caption.
- Effects without a source: tilted phones, 3D objects, glow, glass, gradients that neither the app's DNA nor
  the concept explains. A 3D device needs a reason, a shadow, the set's one light and lens, and appears in at
  most two shots. The default purple-blue gradient, 3D blobs and chrome objects, stock people laughing at
  phones.
- English captions in a Turkish listing (or vice versa); UI language ≠ caption language.
- Unverifiable claims (#1, awards, "millions of users") the user hasn't confirmed. On **Google Play**, Google
  recommends leaving out rankings, award badges, prices, promos, calls to action ("download now") and
  testimonials. Leave them out unless the user decides otherwise, knowing it may limit promotion.
- A phone screenshot in an iPhone Duo or iPad set, or only one iPhone size.
- A stretched, recoloured or painted-over screen; a redrawn badge or button; a number the screens don't show.
- The same composition three times (headline top, phone centre); decoration without a motive; a set that
  would look the same with another app's screens dropped in.

## Honesty and limits

- The library's verdicts (`exemplary/solid/weak`, `ai_smell`) are a designer's judgement by an AI reviewer,
  not conversion data. Use them as taste references, not proof. Headlines in the full catalog are OCR unless
  `headline_verified` is true.
- Library screenshots belong to their publishers: study only. Never copy a set's design, copy or layout system
  closely, and never ship library images.
- Store specs change; `references/store-specs.md` says when they were checked. Verify before upload.
- If you couldn't render or look at an image, say so. Don't claim checks you didn't run.

## Reference map

| Read | When |
|---|---|
| `references/intake.md` | Start of every job: live-app vs new-app flow, listing fetch and fallbacks, brief, screen request |
| `references/design-process.md` | **Every new set:** truth rules, evidence, visual DNA, writing concepts, the campaign system, composition briefs, the look-and-fix loop, the Seenfy pilot |
| `references/scene-format.md` | Writing version-2 set files for `compose.py`: units, campaign, backgrounds, every layer type, per-size variants, what is refused and warned |
| `references/angle.md` | Finding the niche angle (five types), from angle to direction, ownable visual details |
| `references/categories.md` | Per-category playbook: norm, best sets, clichés, where to stand out, three directions |
| `references/directions.md` | Fast path / fallback: the seven preset directions for `render_set.py`, `concepts.py`, brand tokens, overlines, stickers, annotations, shapes, span pairs (§8) - also a reference for scene systems |
| `references/copy-rules.md` | Writing or judging any headline (patterns, banned words EN/TR, swap test) |
| `references/storytelling.md` | Ordering the set, first three shots, set structures |
| `references/layouts.md` | Layout recipes (reference), type, colour, emphasis devices, the HTML route for what no layer can do |
| `references/anti-ai.md` | What makes screenshots look generated or templated, the skill's own habits, and the fix for each |
| `references/localization.md` | Turkish/English specifics, locale mismatches, Turkish capitals |
| `references/store-specs.md` | Pixel sizes, counts, formats; Apple's rules; Google Play's requirements, recommendations and promotion rules, kept apart |
| `references/critique.md` | Structured critique with a scorecard |
| `references/library-guide.md` | What's in the library, how to search it, data insights, curated examples, schema |

## VAS installation notes

- Canonical ID: `store-screenshots`
- Source repository: [`thearkxd/store-screenshots-skill`](https://github.com/thearkxd/store-screenshots-skill) (revision `c25bf66faa7396818c0f7b267e6add4d441573a8`, path `skills/store-screenshots`)
- Author: thearkxd (Alpiworks)
- License: MIT (see bundled `LICENSE` and `NOTICE.md`)
- Role: App Store and Google Play screenshot planning, copywriting, visual DNA extraction, and multi-layer scene design workflow for AI coding agents.
- Prerequisites: Python 3 standard library; optional `Pillow` and `resvg-py` for PNG and SVG rendering, optional `tesseract` for multi-language OCR verification.
- Safety: Installation only links or copies files and writes `.vas-manifest.json`. No runtime/dependency is installed, no background process is spawned, and no external service is connected during `./vas install`.

© thearkxd (Alpiworks) · MIT · huytran1120/vie-agentic-skills

Похожие скиллы

Все скиллы по теме «Дизайн» →

Сначала — store-screenshots от других авторов.

store-screenshots getpaseo Скилл store-screenshots для Claude Code обновляет скриншоты приложения для App Store и Google Play на телефонах и планшетах. Запускается по просьбе переснять изображения или изменить панели магазина. CX Codex +1 420установок app-store-screenshots ParthJadhav Скилл app-store-screenshots собирает редактор на Next.js и ShadCN, в котором вы верстаете и выгружаете скриншоты для App Store и Google Play. CX Codex +1 16 400установок AppScreens: App Store and Google Play Screenshots AppScreens AppScreens: App Store and Google Play Screenshots — MCP-сервер для Claude Code, который создаёт, локализует и выгружает скриншоты App Store и Google Play для витрины приложения. CX Codex +1 ★ 1звёзд репо app-store-screenshots-generator reason-machines Скилл app-store-screenshots-generator собирает рекламные скриншоты iOS-приложения в Next.js и экспортирует PNG для размеров App Store. Подходит для локализованных наборов. CX Codex +1 828установок app-store-screenshot-generation eachlabs Скилл app-store-screenshot-generation генерирует скриншоты для App Store и Google Play через each::sense: рамки устройств, подписи к фичам, локализованные версии. CX Codex +1 223установок aso-appstore-screenshots adamlyttleapps Скилл aso-appstore-screenshots для Claude Code анализирует кодовую базу, выявляет ключевые преимущества и генерирует ASO-скриншоты для App Store через Nano Banana Pro. Запускается из Codex, Cursor и других платформ. CX Codex +1 869установок screenshots-marketing nexu-io Скилл screenshots-marketing для Claude Code, Codex и Cursor генерирует маркетинговые скриншоты через Playwright. Запускается по фразам «marketing screenshot», «hero shot» или «app store screenshot». CX Codex +1 3 000установок

Из того же набора77

Весь набор →
seo-directory-backlinks Скилл seo-directory-backlinks для Claude Code формирует реестр каталогов и внешних ссылок бизнеса. Включается при аудите цитирований, проверке совпадения NAP и подборе отраслевых площадок. CX Codex +1 ★ 85звёзд репо free-design-resources Скилл free-design-resources для Claude Code подбирает бесплатные инструменты, шрифты, иконки, изображения и шаблоны под задачу. Он также проверяет условия лицензии, коммерческое использование и доступность. CX Codex +1 ★ 85звёзд репо gcp-spark-troubleshooting Скилл gcp-spark-troubleshooting для Claude Code помогает разбирать сбои Spark в Google Cloud и Dataproc. Он подключается при диагностике заданий, пакетов PySpark и журналов Spark. CX Codex +1 ★ 85звёзд репо agency-ats-validator-architect Скилл agency-ats-validator-architect для Claude Code проверяет резюме на совместимость с парсерами ATS и нормализует разметку. Аудирует текстовые слои PDF и формулировки по модели Google X-Y-Z. CX Codex +1 ★ 85звёзд репо agency-real-estate-buyer-seller Скилл agency-real-estate-buyer-seller для Claude Code структурирует работу риелтора с покупателями и продавцами недвижимости. Помогает вести сделки, оценивать объекты и готовить оферты. CX Codex +1 ★ 85звёзд репо gslides Скилл gslides для Claude Code читает, создаёт и редактирует презентации Google Slides. Он включается при работе со ссылкой на слайды, их содержимым или экспортом. CX Codex +1 ★ 85звёзд репо agency-application-security-engineer Скилл agency-application-security-engineer для Claude Code проводит ревью кода на уязвимости и выстраивает модели угроз. Помогает внедрить SAST и DAST в пайплайн разработки. CX Codex +1 ★ 85звёзд репо agency-voice-ai-integration-engineer Скилл agency-voice-ai-integration-engineer для Claude Code строит конвейеры транскрибации аудио. Он подключается к задачам распознавания речи, подготовки субтитров и передачи текста в приложения или API. CX Codex +1 ★ 85звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой