AIProductivityTipsPrompting

How to Reproduce AI Results You Actually Like

You generated something great — a perfect image, a brilliant prompt, a clever piece of code. Then you lost it. Here's the trick that fixes that permanently.

6 min read

At some point you’ve generated something with AI that was genuinely great. A perfectly styled image. A prompt that finally got the model to behave exactly how you wanted. A clever bit of code that did exactly what you needed. And then — you lost it.

Maybe you closed the tab. Maybe you ran the prompt again with slightly different wording and got a completely different result. Maybe you can’t even remember which tool you used. Whatever happened, it’s gone, and you can’t get it back.

This happens constantly. AI output is ephemeral by default. The model doesn’t save your session, the randomness is baked in, and small changes in phrasing produce wildly different results. There’s no “undo” that takes you back to the exact configuration that produced the thing you liked.

Here’s the trick I use.

Feed it back and ask for a recipe

The core idea: once you have something you like, immediately ask the AI to give you a structured representation of it — something you can use to reproduce it later.

For an image, that might look like:

“Here’s an image I generated. Can you describe it in a YAML format that captures the key visual elements, style, mood, color palette, composition, and any prompt keywords that would be useful for regenerating something similar?”

The model gives you back something like:

subject: lone lighthouse on a rocky cliff
time_of_day: dusk
color_palette:
  - deep amber
  - slate blue
  - warm grey
mood: melancholic, cinematic
lighting: dramatic side lighting, volumetric fog
style: digital painting, painterly brushstrokes
composition: rule of thirds, subject left, horizon low
negative_elements: no people, no modern structures
prompt_keywords:
  - "lighthouse at dusk"
  - "dramatic sky"
  - "cinematic lighting"
  - "digital painting"
  - "highly detailed"

Now you have something durable. You can save it to a file, paste it into a note, put it in a repo. When you want to regenerate — or generate variations — you feed this YAML back to the model and say “use this as a reference spec”. You’ll get much closer to the original than if you were trying to reconstruct the prompt from memory.

It works for more than images

The same trick generalizes to almost anything AI can produce.

Prompts and system instructions. If you’ve tuned a system prompt through iteration and finally landed on something that makes the model behave exactly right, ask it to summarize itself as a structured spec: tone, constraints, persona, formatting rules, what to avoid. That spec becomes your source of truth you can recreate the prompt from later.

Code patterns. You asked for a function, got one you liked, modified it slightly in a follow-up, and now it’s perfect. Ask the model to extract the pattern into a reusable template or describe the design decisions in structured form — which approach was taken, what tradeoffs it made, what inputs it expects, what edge cases it handles. Now you can reconstruct the pattern even in a different language or framework.

Conversation configurations. If you’ve figured out the right way to phrase things to get a certain type of response — useful for roleplay, tutoring, brainstorming — ask the model to write you an “initialization prompt” that would recreate the same dynamic from scratch. Then save it.

Webpage designs. This one is underused. Take a screenshot of any page — a UI you built, a competitor’s layout, a design you stumbled on — and paste it into a multimodal model. Ask it to extract the design system as a structured spec. You get a detailed inventory of every visual element on the page, described in terms you can hand to any AI coding tool to recreate or riff on.

The prompt I use:

“Here’s a screenshot of a webpage. Please describe its design system in YAML — layout, typography, color palette, spacing, component hierarchy, and any notable UI patterns.”

Output for something like a minimal SaaS landing page might look like:

layout:
  type: single-column
  max_width: 1100px
  sections:
    - navbar
    - hero
    - features_grid
    - testimonials
    - cta_banner
    - footer

navbar:
  style: sticky, transparent on scroll
  items: logo (left), nav links (center), cta button (right)
  cta_button: filled, rounded-full

hero:
  headline: large, bold, centered, ~56px
  subheadline: muted gray, ~20px, max-width 600px centered
  cta: two buttons — primary filled, secondary ghost
  background: off-white with subtle radial gradient

typography:
  font_family: Inter
  scale:
    h1: 56px, weight 800
    h2: 36px, weight 700
    body: 16px, weight 400
    caption: 13px, muted

color_palette:
  primary: "#6366F1" # indigo
  primary_dark: "#4F46E5"
  background: "#FAFAFA"
  surface: "#FFFFFF"
  text_primary: "#111827"
  text_muted: "#6B7280"
  border: "#E5E7EB"

spacing:
  section_padding: 96px vertical
  component_gap: 24px
  inner_padding: 16px

features_grid:
  columns: 3
  card_style: white, 1px border, rounded-xl, subtle shadow on hover
  icon: 32px, colored square background, rounded-md

Now you can paste this into a new conversation — “Build me a landing page using this design spec” — and any decent coding model will produce something structurally and visually faithful to the original. It also works as a reference when you’re building something from scratch and want to stay consistent: just check the spec rather than going back to the screenshot every time.

Why YAML specifically

You could ask for JSON, Markdown, a bulleted list, or plain prose. YAML tends to work well because:

  • It’s human-readable enough that you can scan it quickly
  • It’s structured enough that you can paste it back into a prompt and the model interprets it reliably
  • It maps naturally to the kinds of nested, hierarchical descriptions that AI prompts tend to require

That said, match the format to what you’ll actually do with it. If you’re storing specs in a config file, JSON makes more sense. If you’re jotting notes in Notion, Markdown might be easier to work with. The format matters less than the habit.

The real problem this solves

The deeper issue is that most people treat AI generation as a black box: put something in, hope something good comes out, repeat until it works. When something good comes out, they treat it as luck rather than signal.

The YAML trick reframes good output as structured knowledge. It forces the model to make the implicit explicit — to surface what it “did” to produce that result in a way you can inspect, edit, and reuse. You’re not just saving an artifact; you’re saving the configuration that produced it.

That’s the difference between generating something once and being able to work with it.

A quick workflow

  1. Generate something you like
  2. Immediately, in the same session: “Can you describe this as a YAML spec I could use to reproduce or build on it?”
  3. Copy the output to somewhere durable — a note, a file, a repo
  4. Next time: paste the YAML into a new session as context, then give your new instruction

Two extra seconds while you still have the context. Saves you from starting over every time.