Don't Lose at First Sight: App Icons and Splash Screens for Your Vibe Project
An icon has one job: be found at a glance among dozens of icons. Start from one 1024 master file, cut down to every size, keep words out of the icon, and never fake a progress bar on the splash screen. The walk-through project, people, and numbers in this guide are fictional.

People meet your product as one small square first
Xiao Lin built an expense-tracking app called "Ji Yi Bi" — "jot it down". He spent three months polishing the tracking logic, and on launch day he posted the link in a group chat. The first reply was not praise for the features; it was a question: "That icon… did you just grab a calculator picture at random?" Only then did it hit him: he had spent three months on the tracking logic, and the icon was thrown together the night before launch — a grey square with a white calculator, sitting grey and dull among a pile of colorful icons, hard to even find. The splash screen was rougher still: white background, black text reading "Ji Yi Bi", and a fake progress bar that spun without moving. The app actually launched in 0.8 seconds — the fake progress bar was pure decoration. Users did not know that. All they saw was an opening that looked stuck.

This guide is about the two things vibe developers most often overlook: the app icon and the splash screen. To be clear up front: the walk-through project, people, and numbers in this guide are fictional; the method itself is general, and you can follow it as written. The icon is your product's first face, and the splash screen is the first second after the door opens. If the face is not recognized, nobody taps in; if the first second looks stuck, people turn around and leave. Neither needs artistic skill. Both need a simple routine: one master image, one checklist, one real phone.
The first lesson about icons: be recognizable first, pretty second
An icon on a phone home screen has exactly one job: let a user find you at a glance among dozens of icons. Note the wording: not "look good" — "be found". Good looks come second; being found comes first. A user unlocks their phone dozens of times a day, and your icon occupies less than a centimeter square, surrounded by familiar faces seen every day — WeChat, Alipay, Taobao. If your icon is grey, scattered in shape, or full of detail, the user's thumb slides past it. Not because they dislike you, but because they did not see you.
The test is crude but it works: shrink the icon to fingernail size, drop it into a screen full of real icons, and ask someone who has never seen it to find it within three seconds. If they cannot, the icon has already failed at "being found". There are three common ways to fail. First, too much detail: three or four elements crammed into the icon blur into a blob at small size. Second, colors too pale: grey, white, and beige go invisible on a colorful home screen. Third, a shape too flat: a square plus a line of small text looks, from a distance, like a system folder. Think about it the other way: WeChat is two chat bubbles on green, Alipay is blue with one character, Taobao is orange with one character — one color, one shape, recognizable at a glance. Your icon needs the same: one main color, one main shape, nothing else.
There is one more easy trap: do not put words in the icon, or at least no small words. The app name already shows under the icon; writing it again inside is duplication. Worse, the words blur first when the icon shrinks, and blurred words look worse than no words at all. If the brand name really has to be in the icon, use a single character, big, bold, and readable even when slightly blurred. That is where Xiao Lin went wrong: the calculator lines in his icon were too thin, so at home-screen size the calculator became a grey blob — even he had to hunt for it.
One 1024 master file, cut down to every size
The rule for sizes is exactly one sentence: make a 1024×1024 master file first, then scale down from it — never scale up. Upscaled images go blurry, and blurry images lose points with both store reviewers and users. Make the master once, keep the source file, and export every size from it without redrawing. You do not need many sizes; one table covers it: App Store master 1024, Google Play store icon 512, Android launcher xxxhdpi 192, iPhone app icon @3x 180, Android launcher xxhdpi 144, iPhone app icon @2x 120. The chart below is that table in picture form — export against it.

Treat the sizes as subject to Apple's and Google's official documentation, and re-check them before submitting — platforms occasionally change requirements, and being rejected for following old notes is the most pointless way to lose a week. Three things matter when exporting. First, export PNG, not JPG: icon edges need to be clean, and JPG compression noise shows up badly on flat colors. Second, do not draw the rounded corners yourself: iOS and Android crop the corners on their own, so submit the square original — rounding it yourself means it gets cropped twice. Third, keep the source file: when the master changes, re-export every size from it; do not change one size and submit it alone, or the icons will disagree across platforms.
Android has one more trap to know in advance: adaptive icons. An Android launcher icon has a foreground layer and a background layer, and the system crops it into a circle, a rounded square, or even a teardrop depending on the phone. The safe approach is to keep the foreground artwork inside the middle safe zone and never push key elements to the edge — otherwise, on a differently shaped phone, the edges of your icon get cut off. Check the official Android documentation for the exact safe-zone dimensions; the principle is one sentence: important things in the middle, only background color at the edges.
Three ready-made patterns for what an icon should look like
When you do not know what the icon should look like, do not start from zero — there are three ready-made patterns, and you can pick one and apply it. The first is "one color, one shape": pick a main color and draw one simple shape. An expense app gets dark green plus a white notebook, a pomodoro timer gets red plus a white tomato, a weather app gets blue plus a white cloud. One color, one shape, recognizable no matter how small. This is the most reliable pattern, and it suits almost every utility app.
The second is "one letter": take the most representative character or letter of the product name and blow it up into the icon. "Ji Yi Bi" could take the character for "jot", white and bold on dark green; an English product takes its initial, one capital letter plus one main color. The advantage is that the name and the icon link directly — remember the name and you remember the icon. The disadvantage is that a letter has no picture in it, and done badly it looks like a system folder. If you use this pattern, the letter has to be big and bold; thin-stroke letters such as "i" or a single horizontal stroke are a bad pick, because at small size they become one line.
The third is "a picture of the product itself": draw what the product does. A camera app draws a lens, a music app draws a note, a map app draws a pin. This is the most direct pattern, but also the easiest to overdraw — a lens drawn too finely blurs at small size. The control is to draw only the outline and skip the details: a circle plus a smaller circle is a lens, a triangle plus a vertical line is a play button. Once the outline is right, every detail can go.
Which pattern to pick depends on what the product does: utility apps take "one color, one shape", products with memorable names take "one letter", and functions that can be drawn at a glance take "a picture of the product". Once you pick, do not finalize in one go: make three versions, shrink them to real size, place them side by side in a screen full of icons, and ask three people who have never seen them to pick — whichever is found first is the answer. A designer's instinct is less reliable than a three-second real test.
Splash screens: do not act. Honesty beats decoration
A splash screen has one job: let the user know "the app is opening, it is not stuck". That takes two things: brand identity and a truthful loading state. Brand identity can be an enlarged icon, or the name plus a one-line description — readable in one second. The loading state has to be real: when the data arrives, go in; when it has not, show a skeleton or a spinner. Do not put up a fake progress bar and act. Xiao Lin's fake progress bar is the cautionary tale: the app launched in 0.8 seconds, the bar was still spinning, and the user's first thought was "it is stuck", followed by killing the process and reopening.
There are three more plain rules for splash screens. First, no ads, no popups, no asking for things in the user's first second inside. The splash screen is the hallway, not a market stall. Second, make a separate image for dark mode — do not hard-invert a bright image, because contrast usually breaks when a bright image is flipped dark, and the text becomes unreadable. Third, the shorter the splash screen stays, the better: if it can be 0.5 seconds, do not stretch it to 2. Stretching time does not look "premium"; it looks slow. The highest state a splash screen can reach is that the user barely notices it — a flash, and they are in. That is the opposite of the icon: the icon should be remembered, the splash screen should be forgotten.
Three ways a splash screen dies
There are only three ways a splash screen goes wrong, and avoiding them covers almost everything. The first is the fake progress bar. Progress bars are for things that genuinely wait: downloads, syncing, unpacking — jobs with real progress to show. App launch has no progress to speak of: either it is in within 0.5 seconds, or it is stuck. Putting up a fake bar tells the user "I am waiting for something that does not exist", and when it does not move, their first thought is that something broke. The right approach is: if launch is fast, show no progress indicator at all and just go in; if launch genuinely takes time, show a spinner or a skeleton that says "loading", and do not invent a percentage to lie with.
The second way is asking for things at the door. Ads, popups, or "please rate us five stars" on the splash screen all ask for something before the user has seen what the product looks like. At that moment the user feels nothing for your product, and being asked for something only annoys them. The right approach is: the splash screen carries nothing but brand and state. Ads, rating requests, and subscription prompts come later, after the user has tried it once and tasted something good — only then do they have a reason to listen.
The third way is flashing a white screen or an old image. Launching with a white flash, then the splash image, or the splash image flashing into a different image, makes the app feel like it twitched. That usually means the launch image resources were not ready, or the dark-mode and light-mode images were not paired. The check is simple: cold-launch five times on a real phone, eyes on the screen, watching for white flashes, old images, or double flashes. One flash is a bug; fix it. A splash screen's job is to be forgotten, and any flicker makes the user remember it — in the worst way.
Do not change the icon quietly
There is one more scenario many people never think about: what happens when you want to change the icon later? The icon is how users recognize you, and changing it means changing your face — done badly, long-time users will think the app is gone, or that they downloaded the wrong one. The right approach starts with asking why: is it because the brand changed, or because the old icon genuinely has a problem? If it is only because you are tired of looking at it, do not change it — you are tired of it, but users who glance at it once a day are not.
If you really are changing it, there are rules. First, do not change three things at once. Icon, name, splash screen — change one at a time, wait two weeks for users to adjust, then change the next. Change all three together, and long-time users opening their phones will find a different icon, a different name, and a different splash screen; their first thought is "whose app is this", and their second is to uninstall. Second, do not change the main color too sharply when you change the icon. Dark green to light green is still recognizable; dark green to bright red is not. Color is the icon's first recognition signal: you may change the shape, but keep the color if you can. Third, after the change, say so inside the app: the next time it opens, a small card telling users "we have a new icon" — do not make them guess.
Dark mode and widgets deserve a quick check too. Does the icon blur into one blob on a dark wallpaper? Is the tiny icon on a widget still recognizable when shrunk even further? Both are easy to forget. Before release, spend five minutes: switch to a dark wallpaper, add the widget to the home screen, and confirm the icon is still recognizable. Only then is the check complete.
Run the checklist on a real phone before release
Once the icon and splash screen are done, do not just glance at them on a computer and submit. A computer screen is big and bright, and it hides every flaw. The right way is to install it on a real phone and run through this checklist in real usage. First, put the icon on a home screen full of icons — can you find it within three seconds? Second, switch between a dark wallpaper and a light one — is the icon recognizable on both? Third, turn the brightness down and look at it in sunlight — are the colors still distinguishable? Fourth, launch the app five times — is it a flash and in every time, or does it ever stall, flash white, or flash an old image? Fifth, uninstall and reinstall once — do the icon and name display correctly? All five have to pass before you submit.
While you are at it, check the store screenshots: is the icon in the screenshots the same one you submitted? Does the splash screen in the screenshots match the real splash screen? Many apps get rejected not because the icon is ugly, but because the screenshots and the real thing disagree, and reviewers conclude you are showing one thing and shipping another. Xiao Lin redid his icon following this checklist: the main color became a recognizable dark green with a white notebook, all the words came out, the splash screen kept only the icon and the name, and the fake progress bar was deleted. The redo took an afternoon. After relaunch, nobody in the group chat asked "what is that icon" again. Nobody praised the icon either — but nobody asked what it was. For an icon, that is a pass.
How often should you re-check the icon and splash screen after they are done? Not daily — but before every major release, run through it again: is the master file still there? Are all sizes still exported from the same master? Does the splash screen still behave on the new OS version? Are the dark-mode images still paired? Ten minutes before a major release beats fixing it after users complain in the reviews that "the icon went blurry". An icon and a splash screen are the product's face: most days nobody notices them, but when they are dirty, the whole world sees it.
One last line: icons and splash screens are not art problems; they are recognition problems. Recognizable, enterable, not stuck — get those three right, and your product earns the chance to show users what is inside. However good the features are, if the face cannot be recognized and the door will not open, it is all for nothing.
Comments (0)
Related articles
One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.
localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.
You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.