How to Write an AI Prompt for a Cosmetic Formulation: A Step-by-Step Guide

Introduction: why cosmetic developers need AI prompts

Developing a cosmetic formulation is a process that traditionally takes weeks, sometimes months. A formulating chemist selects a base, tests the compatibility of active ingredients, calculates the pH balance, checks the emulsion's stability at different temperatures, and then adjusts the formula based on lab trial results. Every stage demands deep expertise in organic chemistry, dermatology, and emulsification technology — and the human factor is unavoidable here: an error in calculating a preservative's percentage, or an overlooked incompatibility between two ingredients, can cause an emulsion to separate, active ingredients to lose potency, or an allergic reaction in the end user.

This is exactly where AI models — large language models trained on vast bodies of scientific literature, patent databases, and technical documentation — become a working lab tool. But the quality of an AI's output depends directly on the quality of the query. A vague prompt like "come up with a cream for dry skin" produces an equally vague answer that's often useless in practice: no concrete INCI names, no percentages, no emulsification temperature regimes. The chemist gets text that sounds plausible but won't survive scrutiny in the lab.

This is where the key skill covered in this guide comes in: how to write AI prompts for cosmetic formulation — that is, how to phrase a request so the AI produces not generic phrases but a working formula foundation: specific ingredients with percentage ranges, emulsion-phase logic, pH and temperature parameters, and potential compatibility risks. This isn't magic or "prompt engineering for hype's sake" — it's a structured approach to briefing the model, much the way a chemist would phrase a request to an expert colleague.

What changes when moving from manual development to AI-assisted development

It's important to understand: an AI model doesn't replace lab testing and doesn't override the chemist's expertise. It shortens the time spent on routine steps — selecting alternative emulsifiers, calculating a starting active concentration, generating compatibility hypotheses. The developer gets a draft formula in minutes instead of days, then applies their own expertise to validate and test it.

• Faster iteration — instead of one formula a week, you can test 5-10 hypotheses in a day before heading to the lab.
• Lower barrier to entry — a beginner formulator gets a structured starting point instead of a blank page.
• Systematized knowledge — a well-built prompt forces the developer to state product requirements more clearly (skin type, target pH, stability, raw-material cost).

In the sections that follow, we'll break down step by step which blocks a prompt should contain to produce a workable formulation: how to specify product type and target audience, how to phrase ingredient and budget constraints, how to request a percentage composition and process sheet from the model, and how to evaluate and refine the result you get. Each step is illustrated with concrete prompt examples — from weak phrasings to working technical briefs you can hand straight to the lab notebook.

How AI understands the language of chemistry: how a language model generates formulations

A language model doesn't "know" chemistry the way a chemist with a degree does. It works with text as a statistical object: every word, including ingredient names under the INCI nomenclature, is converted into a numeric vector — a token — and the model predicts the most probable sequence of tokens that logically continues the prompt. To a language model, a formulation isn't a chemical system with phases, pH, and compatibility — it's a language pattern encountered many times in the training data: patents, scientific papers, formulator forums, INCI/CTFA regulatory documents.

Tokenizing chemical names

The problem is that INCI nomenclature doesn't map cleanly onto standard natural-language tokenization. The model may split the name Sodium Ascorbyl Phosphate into fragments that don't align with the chemical morphemes: "Sodium," "As," "corbyl," "Phosphate." This creates a risk of semantic drift — the model associates the ingredient not with its actual chemical function, but with the entities closest to it by vector distance that appeared in similar contexts during training. According to research on NLP models in chemical domains (Guo et al., 2022; Schwaller et al., 2021), specialized SMILES tokenizers and chemical notation deliver 15–30% more accurate structure recognition compared to the generic natural-language tokenizers used by most conversational AI systems, including GPT-like models. In practice, this means an ordinary chatbot interprets a chemical name more by the context in which it's mentioned in text than by molecular logic.

Where the model's "chemical intuition" comes from

What looks like an understanding of ingredient compatibility is, in reality, a statistical correlation. If the training corpus contains the pairing "Niacinamide + Vitamin C low pH = instability" thousands of times, the model will reproduce that warning with high probability — without any "understanding" of the transamidation reaction involved. The problem arises where the corpus is sparse or contradictory: for new peptides, rare plant extracts, or unconventional emulsifier combinations, the model either hallucinates plausible-sounding but incorrect data, or averages its answer across unrelated analogies (Bender & Koller, 2020, in the context of "stochastic parrots" — criticism of LLMs manipulating the form of language without grounding in reality).

How the answer gets structured

The output format — a phase table, percentages, ingredient addition order — is also the result of pattern-matching, not calculation. The model has been trained on tens of thousands of formulation examples with a particular text architecture: Phase A / Phase B / Phase C, heating temperature, emulsification order. When a prompt contains trigger words ("emulsion," "serum," "SPF"), it activates the attention regions tied specifically to that cluster of structures. This explains why a vaguely worded request returns a generic, "averaged" recipe — the model picks the most statistically safe template rather than the one optimal for your specific task.

The practical takeaway for prompt engineering: the more precisely a request mirrors the structure and terminology typical of high-quality sources (scientific publications, regulatory guides, professional formulation databases), the higher the odds the model activates a relevant pattern rather than an averaged one. That's covered in the next sections, which break down the actual architecture of a prompt.

Anatomy of the ideal prompt: structure, context, and constraints

A prompt for generating a cosmetic formulation isn't a free-form question — it's a technical brief. An AI model works statistically: it predicts the most probable continuation of the text based on what you feed it as input. The more precise and structured the input, the less room there is for "guesswork," and the closer the result gets to a working formula rather than an abstract text about a cream.

A good formulation prompt almost always consists of five required blocks. Skip any one of them, and the model fills the gap with its own assumptions — which may not match your technical constraints.

Block 1: role

The first line of the prompt gives the model a "professional mask" — the context from which it selects vocabulary, level of detail, and reasoning logic. A phrasing like "You are a formulating chemist experienced in developing O/W emulsions" switches the model into a mode where it's more likely to use correct INCI terminology, mention emulsifier HLB balance and typical pH ranges, rather than write marketing copy for a landing page.

Without this block, the model defaults to a generic, "safe" response style — whatever is statistically more common in training data about cosmetics in general, including blogs and ad copy.

Block 2: task

The task should be framed as a specific technical action, not an open-ended question. Compare these two phrasings:

• "Come up with a cream for dry skin" — a vague request; the model will pick the most typical answer out of thousands of similar texts in its training set.
• "Build a base formula for an O/W moisturizing cream with an 18–22% lipid phase, mid-polarity emollients, and a preservative system based on Sodium Benzoate and Potassium Sorbate" — a task with measurable parameters that sharply narrows the probability space of the answer.

Block 3: input parameters

This is the product's technical passport, which you hand to the model explicitly. The fuller the list, the lower the risk of getting a formula that's incompatible with your equipment or target audience.

Block 4: output format

By default the model tends to answer with connected prose and explanations. That's inconvenient for a formulation — you need a table with phases, percentages, and addition order. Spell out the structure explicitly: "Present the result as a table: Phase, INCI name, % content, addition temperature, ingredient function." This dramatically increases the answer's usability for further work — costing, transferring into a lab notebook, or comparing versions.

Block 5: safety constraints

This block is what separates a working tool from a toy. The model has no built-in regulatory module — it doesn't "know" the EC 1223/2009 or CIR limits by default unless you explicitly ask it to work within them and then verify the result yourself. So the prompt should build in explicit constraints:

• maximum active-ingredient concentrations (e.g., "Retinol no more than 0.3%");
• a ban on combinations with known incompatibility (acids + certain vitamin C forms);
• a requirement to state each ingredient's functional class, not just its name.

The "role → task → parameters → format → constraints" structure works as a checklist, not a rigid template — the order of the blocks matters less than their completeness. General prompt-engineering principles (detailing context, spelling out format explicitly, breaking a complex task into sub-points) apply here just as they do in any other technical field of working with language models.

Chemical constraints and ingredient compatibility: what the prompt needs to know

A language model doesn't understand chemistry — it predicts likely token sequences based on patterns in its training data. That means that without explicit constraints in the prompt, the model can generate a formula that looks plausible but is physically unstable or chemically incompatible. The developer has to write into the prompt the same constraints an experienced formulating chemist keeps in their head.

pH compatibility: the invisible barrier

Most active ingredients only work within a narrow pH range, and combining two "beneficial" ingredients with different optima often neutralizes both. Ascorbic Acid (ascorbic acid, vitamin C in its pure form) is stable at pH 3.0–3.5, while most peptides and ceramides require pH 5.0–6.5 — at acidic pH, peptide bonds hydrolyze faster (per Pinnell, 2003, pH below 3.5 is critical for L-ascorbic acid stability).

If the prompt doesn't specify the system's target pH, the model may "combine" incompatible actives into a single phase simply because they statistically co-occur often in texts about "anti-age formulas."

Emulsification: HLB and phase behavior

An emulsion is stable when the emulsifier's HLB (hydrophilic-lipophilic balance) matches the required HLB of the oil phase. The prompt should explicitly state the emulsion type (O/W, W/O, or multiple), the oil phase percentage, and the emulsification temperature regime.

• O/W emulsions generally need an emulsifier with HLB 8–16, with an emulsification temperature of 70–75°C for waxy components.
• W/O emulsions — HLB 3–6, often using Polyglyceryl-3 Diisostearate or similar.
• Multiple emulsions (W/O/W) require a two-step process and require noting storage stability (usually unstable without special stabilizers, per Tadros, 2013).

Stability: temperature, light, oxygen

Many actives don't degrade instantly — they degrade during storage. The prompt should treat stability conditions as a constraint, not a desired outcome.

Active-ingredient interactions: explicit conflicts

A classic example is combining Retinol and AHA/BHA acids in a single phase. Both classes increase stratum corneum sensitivity, and combining them intensifies irritation without a proportional gain in efficacy (per Kligman, 1998, on the synergy of irritation when combining retinoids and acids). A prompt asking for the "most effective possible anti-age formula," without a compatibility constraint, risks getting exactly this combination — effective in theory, but unsuitable for sensitive skin.

Another common conflict is cationic surfactants (e.g., Cetrimonium Chloride) with anionic systems (Sodium Lauryl Sulfate and similar): mixing them produces insoluble complexes and both components lose their function. This is a purely electrostatic constraint that the AI doesn't "know" intuitively — it has to be spelled out explicitly: "do not combine cationic and anionic surfactants in the same phase."

What to write into the prompt as a chemical constraint

1. The target pH range of the finished formula and the pH sensitivity of each active ingredient.
2. The emulsion system type, the required HLB, and the temperature regime for phases A and B.
3. Storage conditions (light, temperature, oxygen exposure) and whether antioxidant protection is needed.
4. An explicit ban on known conflicting pairs (retinol + high-concentration acids, cationic + anionic surfactants, copper peptides + vitamin C).
5. Maximum allowed active concentrations under regulatory limits (e.g., Salicylic Acid — up to 2% in leave-on products under EU regulation).

The more detail the prompt provides on these boundaries, the less likely the model is to "smooth over" a real chemical conflict just to produce a formally clean-looking answer — for more on structuring such constraints, see the piece on prompt anatomy.

A step-by-step algorithm: from product idea to finished prompt

A good prompt isn't born in one attempt — it's built step by step, just like a formulation itself: first the frame, then the details, then correction. Below is a working sequence you can apply to any product, from a serum to a lip balm.

Step 1. Define the target product as narrowly as possible

"Face cream" is a poor starting point: the AI will either produce an averaged-out template or start asking clarifying questions mid-answer, losing focus. You need a narrow category with texture and purpose: not "cream," but "a lightweight gel-cream for combination skin with a mattifying effect," or "a night balm-mask for dry, dehydrated skin."

• Category: emulsion (O/W or W/O), gel, serum, balm, emulsion fluid
• Texture: light/rich, feels oily/dry, fast-absorbing
• Purpose: hydration, sebum control, anti-aging, barrier repair

Step 2. Fix the skin type and physiological context

Skin type changes not only which actives to use, but the allowable concentration of emollients, surfactants, and acids. The prompt shouldn't say a generic "for sensitive skin" — it needs specifics: presence of couperose, acne tendency, signs of barrier disruption, seasonal use.

• Skin type: dry, oily, combination, sensitive, mature
• Conditions: acne, rosacea, hyperpigmentation, signs of aging
• Use conditions: day/night, climate, compatibility with makeup or SPF

Step 3. List the key actives and their role

Here it's important not just to list ingredients but to state each one's function — this sharply increases the accuracy of the answer. A prompt like "include Niacinamide and Hyaluronic Acid" is worse than "include Niacinamide 4% as a sebum regulator and Sodium Hyaluronate 0.5% as a plumping humectant."

Step 4. Set the desired output format before sending the prompt

This is the step most often skipped — and the result is unstructured text you then have to manually transfer into a table. You need to request the format explicitly, within the body of the prompt, not as a separate follow-up question.

• Table format: "Present the result as a table with columns: Phase, INCI name, % addition, addition temperature, Function"
• INCI order: "Give the final INCI list in descending order of concentration, as required for labeling"
• Phase notes: "After the table, give a brief description of the order for mixing phases A, B, C"

Without this requirement, the model picks whatever format is convenient for it — usually connected prose, from which it's hard to quickly pull out numbers for a lab pilot batch.

Step 5. Iterate and refine

The AI's first answer is a draft, not a final formulation. Working properly with a prompt is a conversation with refinements, not a single perfect request.

1. Get a base formulation from a general prompt
2. Check active-ingredient compatibility and pH range manually, or ask the AI to justify its emulsifier choice
3. Send a follow-up prompt: "Replace the emulsifier with a lighter one for a summer texture, keeping emulsion stability at 25°C"
4. Ask it to recalculate the percentages given the new constraint — for example, reducing the phase's overall oiliness
5. Finalize the request for a full INCI list and phase-addition regime (cold/hot phase, 70–75°C for the water and oil phases in a classic O/W emulsion)

This step-by-step approach turns a prompt from a one-off request into a working development tool — a formulation draft you can quickly adjust rather than rewrite from scratch with every change.

Prompt examples: from a basic moisturizer to a complex serum

The theory of prompt anatomy only works once you see the difference on real formulas. Below are three levels of complexity: a basic cream, a cream with actives, and a multi-phase serum. At each level, we show a weak prompt, its result in broad strokes, and a reworked version that gives the chemist a working formula base rather than ad copy.

Level 1: moisturizing cream — from a vague question to a phased formula

Weak prompt: "Make a formula for a moisturizing cream for dry skin." In response, the AI gives a list of 6–8 ingredients with no percentages, no phase breakdown, often with generic phrases like "moisturizing components" instead of concrete INCI names. That answer isn't usable in a lab — it's more a product-category description than a weighing sheet.

The improved version sets the output format and the technical framework:

The result of such a request is a table with phases, concrete percentages (for example, water phase 70%, oil phase 15%, active phase 5%), and the temperature points for adding the emulsifier (70–75°C) and cooling to 40°C before adding preservatives and heat-sensitive actives. The difference isn't in "idea quality" — it's in the document's usability for further work: in the second case, the chemist gets a draft formulation sheet, not a list of words.

Level 2: cream with actives — adding compatibility constraints

At this level, a weak prompt fails differently: the developer names actives but doesn't set compatibility constraints, and the model may propose a combination that in practice causes emulsion separation or a loss of an ingredient's activity.

The key evolution here is the shift from naming an effect ("glowing skin") to a specific ingredient pair with percentages and an explicit request to flag conflicts. Without that step, the model defaults to the "safe" combination, which may not match the developer's actual goals — for example, it may deliver a pricier or less effective form of an active simply because it conflicts less often.

Level 3: complex serum — a multi-phase prompt with a cascade of constraints

Serums with multiple actives are a stress test for a prompt's maturity, because they require accounting for pH compatibility, addition order, solubility, and storage stability all at once. A weak prompt like "a serum with retinol, hyaluronic acid, and peptides for wrinkles" is almost guaranteed to yield a combination that's unstable on paper: Retinol is light-unstable and needs separate encapsulation or deaerated packaging, while peptide complexes are often sensitive to a pH range different from the one comfortable for hyaluronic acid.

A working version of the prompt breaks the task into layers:

1. Specify the form of each active: Sodium Hyaluronate (low-molecular-weight fraction), Encapsulated Retinol 0.3%, a peptide complex with a stated stability range of pH 5.0–6.0;
2. Explicitly ask to separate phases by compatibility and state which actives go in before emulsification/gelling and which go in during cool-down;
3. Require the model to flag risk points: light sensitivity, oxidative instability, need for an antioxidant pairing (e.g., Tocopherol 0.5%);
4. Output format — a phase table with ingredient %, temperature, and a rationale for the addition order.

With that level of detail, the AI's answer stops being "a list of trending ingredients" and becomes a structured draft where the formula's logic is visible: why the retinol is encapsulated, why the antioxidant is added at that particular phase, and what pH range was chosen as the compromise between hyaluronic acid's stability and the peptides' activity. This isn't a production-ready formulation — final validation still rests with the chemist and lab testing — but that level of prompt detail is what makes the result a foundation for real development, not an aesthetic exercise.

Common prompt-writing mistakes and how to avoid them

Even experienced developers who've mastered prompt structure and chemical constraints regularly make the same mistakes. They have nothing to do with a lack of cosmetic-chemistry knowledge — the problem is in how the request is phrased. The AI generates exactly what the text describes, and any omission turns into a formulation you'll have to rewrite from scratch.

Mistake #1: no numeric concentration constraints

The most common problem: the prompt names an ingredient with no concentration range. A request like "add Niacinamide for brightening" leaves the model free to pick any figure from 1% to 20%, while in practice, above 5% without pH buffering, the risk of redness and stinging rises. The model doesn't know who your audience is or what your irritation threshold is — unless you state it explicitly.

• Bad: "Make a serum with vitamin C and niacinamide"
• Good: "Make a serum with Sodium Ascorbyl Phosphate 3–5% and Niacinamide 4%, final pH 5.5–6.0"

Mistake #2: ignoring regulatory constraints

Many prompts never mention which market the product is being developed for, even though that's critical. The EU Cosmetic Regulation 1223/2009 bans or restricts hundreds of substances (Annex II and III), while the FDA in the US regulates differently — for instance, treating UV filters as OTC drugs. If you don't specify the region, the AI may suggest a preservative that's allowed in one jurisdiction and banned in another, or exceed a filter's concentration limit.

Mistake #3: vague texture and sensory phrasing

Words like "light texture," "pleasant cream," "not sticky" are subjective and don't translate into chemical parameters. The AI may interpret "light" either as low viscosity or as a small oil-phase content — and those interpretations lead to completely different formulas. You need to translate sensory wishes into measurable parameters: viscosity in mPa·s, percentage of volatile silicones, emulsion type (O/W or W/O).

Mistake #4: no information on stability phase and pH

Prompts often describe actives but forget the process context — addition temperature, phase order, target pH of the finished product. As a result, the AI may propose combining Ascorbic Acid (needs pH < 3.5) and Niacinamide in a single phase without accounting for the fact that at low pH a reaction can form nicotinic acid and cause skin redness. Stating the target pH range and temperature regime immediately cuts off unstable combinations.

Mistake #5: too generic a request with no role specified for the AI

A prompt like "come up with a face cream" without specifying that the model should act as a cosmetic chemist mindful of regulatory rules often produces marketing copy instead of a formula with percentages and phases. Explicitly stating the role ("you are a cosmetic chemist, answering strictly in the format of an INCI table with percentages") changes the answer's structure dramatically.

Self-check list before sending a prompt

1. Are precise concentrations (%) specified for each active ingredient?
2. Is the sales region and its regulatory framework stated?
3. Have sensory preferences been translated into measurable parameters (viscosity, emulsion type)?
4. Is the target pH range and phase-addition temperature regime specified?
5. Is the AI's role and the output format defined (INCI table, percentages, phases A/B/C)?

Each of these points closes a specific gap in the prompt that the AI would otherwise fill in on its own — and in cosmetic chemistry, filling gaps almost always means a risk of incompatibility or non-compliance.

Checking and validating AI formulations: why the prompt is only the beginning

Even a perfectly built prompt — with pH, temperature regime, and incompatibility categories all specified — produces a text hypothesis, not a verified formula. A language model predicts the most probable token sequence based on patterns in its training data — it doesn't calculate an emulsion's HLB balance, doesn't run a rheology test, and doesn't know how a specific batch of Xanthan Gum will behave at 45°C three months into storage. The gap between "text that resembles a formulation" and "a formulation ready for production" closes only through lab validation.

Calculating safe dosages: where AI most often gets it wrong

The model is trained on open sources — scientific papers, patents, formulator forums — and tends to average concentration ranges without accounting for the region's regulatory context, product type, or target audience. It might suggest 20% Niacinamide for a serum, citing the general trend toward "high concentrations," without mentioning that for sensitive skin the safe threshold starts at 4–5%, and that irritation-potential data above 10% (per Bissett et al., 2004; Wohlrab & Kreft, 2014) call for a separate patch test.

• Active ingredients with a narrow therapeutic window — retinoids, AHA/BHA acids, pure L-form vitamin C — need cross-checking against the CIR (Cosmetic Ingredient Review) and SCCS (Scientific Committee on Consumer Safety) databases, not just against the model's answer.
• Preservatives — the AI often suggests a "standard" 0.5–1% without accounting for the finished formula: the real effective dose depends on pH, the presence of chelators, and other antimicrobial components in play.
• Essential oils and fragrance components — the model may fail to account for the cumulative IFRA limit when combining several fragrance materials in one formula.

Stability testing: what a prompt cannot replace

The stability of an emulsion, suspension, or gel is determined by the system's behavior under physical and thermal stress, not by a text description. The minimum verification protocol, applied regardless of whether the source formula was generated by a person or a model, covers several stages.

Methods for assessing the physical and chemical stability of emulsion systems are described in detail in the literature on cosmetic-formulation rheology (per Tadros, 2004; Eccleston, 1997) — these protocols remain the gold standard regardless of how "smart" the source formula's generation process was.

The cosmetic chemist's role: interpretation, not rewriting

The specialist's job at this stage isn't to discard the AI's output but to conduct a structural review: check phase compatibility, recalculate emulsifier HLB values against the real oil-to-water ratio, adjust the pH-buffer system, and confirm preservative dosages via a challenge test rather than a table minimum. The chemist also assesses manufacturability — whether the proposed phase-addition sequence can actually be reproduced on real equipment at the target batch size, not just in a 50 g lab beaker.

A breakdown of specific cases where an AI formulation did and didn't pass verification is covered in /blog/keys-oshibki-formulirovaniya-kosmetiki — it shows that the final share of working formulas after the full verification cycle rarely exceeds 30–40% of the originally generated variants. That's not a sign the prompt was useless — it confirms its real role: a hypothesis draft, not a finished product.

Conclusion: how prompt engineering is changing cosmetic development

Prompt engineering doesn't replace cosmetic chemistry — it changes how time is spent within the development process. What used to take hours of searching INCI references for combinations and calculating pH compatibility can now be produced as a draft in minutes. But a draft remains a draft: it requires stability testing, calculation of real-world concentrations, and an understanding of why the formulation works the way it does. A specialist who can do both — phrase a good request and properly verify the result — has a working tool, not a source of risk.

Three pillars of working well with AI formulations

Everything in this guide comes down to three interconnected principles:

• Request precision — the prompt should state the product type, target audience, desired texture, ingredient constraints, and price segment. A vague request produces a vague — and often chemically incorrect — result.
• Chemical literacy in framing the task — stating pH ranges, emulsification temperature regimes, and incompatible pairs (for example, Ascorbic Acid and Niacinamide at high concentrations without buffering) reduces the chance of AI errors already at the generation stage.
• Mandatory human validation — no AI-generated formulation should reach a lab sample without a mass-balance check, phase-compatibility check, and real-world storage stability testing.

Checklist before sending a formulation into development

Where to go from here

Prompt engineering for cosmetic formulation is a skill that grows alongside your depth of understanding of formula chemistry. The more precisely a specialist understands why a cream needs Xanthan Gum at a specific concentration, or why an emulsifier with a particular HLB suits a given system, the more precise the prompt becomes — and the fewer iterations it takes to turn an AI draft into a working sample. Mastering that combination — a structured request plus chemical expertise — shortens the path from idea to prototype, but it doesn't shrink your responsibility for what ends up on the end user's skin.

A well-phrased prompt is half the job; the other half is a reliable source, not "plausible-sounding" text. At the Walker Formulation Academy Club, that's exactly what the AI Chemist is for: an assistant tied to a verified INCI/CosIng database (via RAG technology), so it relies on vetted data instead of inventing concentrations and compatibilities. And a live instructor will review your formula wherever no prompt can help.