store-screenshots · huytran1120 — скилл для Claude Code: скриншоты приложений
Скилл store-screenshots для Claude Code создаёт и оформляет скриншоты для App Store и Google Play на основе реальных экранов приложения.
MIT ★ 85 обновлён 2026-11-15
npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a claude-codeЧто делает 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-code2Вручную: положить файлы
~/.claude/skills/store-screenshots/SKILL.mdПапка скилла целиком; для одного проекта — .claude/skills/store-screenshots/
1Через Skills CLI (Vercel)
npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a codex2Вручную: положить файлы
.agents/skills/store-screenshots/SKILL.mdДля всех проектов — ~/.agents/skills/
1Через Skills CLI (Vercel)
npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a cursor2Вручную: положить файлы
.cursor/skills/store-screenshots/SKILL.mdCursor читает и .agents/skills/, и .claude/skills/
1GitHub CLI
gh skill install huytran1120/vie-agentic-skills skills/store-screenshots2Вручную: положить файлы
.github/skills/store-screenshots/SKILL.md1Через Skills CLI (Vercel)
npx skills add huytran1120/vie-agentic-skills --skill store-screenshots -a gemini-cli2Командой платформы
gemini skills install https://github.com/huytran1120/vie-agentic-skills --path skills/store-screenshotsВручную: положить файлы
.devin/skills/store-screenshots/SKILL.mdСтарый путь .windsurf/skills/ тоже читается
Claude.ai
Упакуйте папку в zip и загрузите в Settings → Capabilities → Skills
По шагам, с командами для каждой платформы: Как установить скилл в 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 от других авторов.