Make Lovable produce more consistent output by making the prompt and runtime deterministic: add a strict system prompt and few-shot examples, set low sampling (temperature=0) in your LLM call, enforce a strict JSON output schema and validate/normalize responses in app code, and put your API key in Lovable Secrets so runs are stable.

Concrete Lovable prompts to paste (do these in chat to have Lovable apply the changes)

• Set the model call to deterministic sampling (server-side) — paste this to update src/llm/client.ts to always call the model with temperature 0 and clear stop sequences:

// Edit src/llm/client.ts
// Replace your current LLM call with this implementation.

import fetch from 'node-fetch' // // Lovable will add/import if needed

export async function callLLM(prompt: string) {
  const res = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${process.env.OPENAI_API_KEY}` // // ensure secret set in Lovable Secrets
    },
    body: JSON.stringify({
      model: 'gpt-4o', // // change to the model you use
      messages: [{ role: 'system', content: prompt }],
      temperature: 0, // // deterministic
      top_p: 1,
      n: 1,
      max_tokens: 800,
      stop: ["</END>"] // // include an explicit stop token you include in your prompts
    })
  })
  return res.json()
}

• Create a strict templated prompt with explicit output schema & few-shot examples — paste this to create src/llm/promptTemplates.ts

// Create src/llm/promptTemplates.ts
// Use this template for every call to the model.

export const SYSTEM_PROMPT = `You are a JSON-output-only assistant. Always respond with valid JSON and nothing else.
The response must be a single JSON object with keys: "title" (string), "summary" (string), "tags" (array of strings).
End the output with the token </END> so the caller can stop generation.`

export const EXAMPLE_PROMPT = `Example INPUT: Turn "Fix home page bug" into JSON.
Example OUTPUT:
{"title":"Fix home page bug","summary":"Home page crash due to null user. Added guard and unit test.","tags":["bug","frontend"]}</END>`

• Add a runtime validator that strictly parses and normalizes LLM output — paste this to create src/llm/validateResponse.ts

// Create src/llm/validateResponse.ts
// Lightweight runtime checks, no external libs required.

export function validateAndNormalize(raw: string) {
  // // strip trailing text after first JSON object
  const start = raw.indexOf('{')
  const end = raw.lastIndexOf('}')
  if (start === -1 || end === -1) throw new Error('No JSON object detected')
  const jsonText = raw.slice(start, end + 1)
  let obj
  try {
    obj = JSON.parse(jsonText)
  } catch (e) {
    throw new Error('JSON parse failed')
  }
  // // minimal shape checks
  if (typeof obj.title !== 'string') throw new Error('Missing title')
  if (typeof obj.summary !== 'string') throw new Error('Missing summary')
  if (!Array.isArray(obj.tags)) obj.tags = []
  // // normalize tags to strings
  obj.tags = obj.tags.map(t => String(t))
  return obj
}

• Wrap calls with validation and a single structured retry (code changes) — paste this to update src/llm/runner.ts

// Edit/create src/llm/runner.ts
// Calls the LLM, validates, and retries once only when parsing fails.

import { callLLM } from './client'
import { SYSTEM_PROMPT, EXAMPLE_PROMPT } from './promptTemplates'
import { validateAndNormalize } from './validateResponse'

export async function generateStructured(inputText: string) {
  const prompt = `${SYSTEM_PROMPT}\n\n${EXAMPLE_PROMPT}\n\nINPUT: ${inputText}`
  const res = await callLLM(prompt)
  const raw = res.choices?.[0]?.message?.content ?? ''
  try {
    return validateAndNormalize(raw)
  } catch (e) {
    // // one structured retry with a clearer parser instruction
    const retryPrompt = `${SYSTEM_PROMPT}\nRespond ONLY with JSON object. Do NOT include commentary. INPUT: ${inputText}`
    const retryRes = await callLLM(retryPrompt)
    return validateAndNormalize(retryRes.choices?.[0]?.message?.content ?? '')
  }
}

• Set OPENAI_API_KEY in Lovable Secrets — paste this instruction in chat so Lovable shows you how:
  • Open the Lovable Secrets UI and add a secret named OPENAI_API_KEY with your key.
• Test in Lovable Preview and Publish — paste this instruction so Lovable will run a Preview request using a sample input and show the normalized JSON output in Preview; then use Publish when happy.

Notes and constraints

• Keep temperature: 0 to reduce randomness. This happens in your app code — no terminal needed.
• If you need external packages (zod, ajv), you'll have to sync to GitHub and run npm install in your own environment or CI. Mark that as outside Lovable (terminal required) in the chat when you paste the change.
• Use the Preview action to validate outputs quickly. Use Publish or GitHub sync to save changes.

Make outputs consistent by treating the model like an external, versioned service you control: pin model & temperature in a single config file, enforce a strict structured-output schema + parser, normalize inputs, use deterministic seeding for any randomness, keep canonical prompt templates and examples in the repo, store API keys in Lovable Secrets, and add snapshot/golden tests you run via GitHub CI (Preview for quick checks, GitHub sync to run terminal/CD steps).

Concrete Lovable prompts to paste (do these in Lovable chat)

Paste each block below into Lovable chat. Each block is a single Lovable instruction asking the assistant to create/update files. Be explicit: these edits use paths in your repo and include example code the assistant should write.

• Pin model & temperature centrally (create src/config/lm.ts)

// Please create a new file src/config/lm.ts with a single source of truth for model settings.
// This file will be imported anywhere we call the LLM so we always use the same model + temperature.
export const LM_CONFIG = {
  // the name here is an example; keep it configurable from Secrets UI if needed
  model: "gpt-4o-mini", // update if you use a different model
  temperature: 0.0,
  top_p: 1.0,
  max_tokens: 1200
};

// Also update any code that directly passes model/temperature to import and use LM_CONFIG instead.

• Create a strict structured output schema and parser (src/specs/response-schema.json and src/lib/parseResponse.ts)

// Create src/specs/response-schema.json with a JSON Schema the app expects back from the LLM.
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["intent", "data"],
  "properties": {
    "intent": { "type": "string" },
    "data": { "type": "object" }
  },
  "additionalProperties": false
}

// Create src/lib/parseResponse.ts that validates LLM text output against the schema and returns errors if invalid.
// Use a small runtime JSON-schema validator (e.g., ajv) in your project dependencies.
import schema from "../specs/response-schema.json";
// // validate string from LLM: if not valid JSON or fails schema, return a structured error so UI can show it.
// // The assistant should implement this using your project's preferred JSON schema validator.

• Add canonical prompt templates (src/prompts/\*.md) and a prompt wrapper that injects examples

// Create src/prompts/task_template.md containing a single stable instruction the assistant will always use.
// Example content:
You are a JSON-only responder. Always respond with valid JSON matching the schema in src/specs/response-schema.json.
Do not include any explanation or surrounding text. Use these named placeholders: {{user_input}}, {{examples}}.

// Then create src/lib/buildPrompt.ts that loads template + inserts a small set of fixed examples (few-shot) and a final user_input.
// The assistant should implement file edits so all LLM calls use buildPrompt() instead of ad-hoc prompt strings.

• Make randomness deterministic when needed (create src/utils/seededPRNG.ts)

// Create src/utils/seededPRNG.ts implementing a small seeded PRNG (mulberry32 or xorshift).
// Export a function seedFromString(key: string) and random() that returns a deterministic number in [0,1].
// Use this only for generating stable tokens, deterministic selection, or pseudo-random IDs that must reproduce between runs.

• Add input normalization and sanitization (src/lib/normalizeInput.ts)

// Create src/lib/normalizeInput.ts that:
// // - trims and collapses whitespace
// // - normalizes punctuation and Unicode (NFKC)
// // - removes characters outside allowed set if needed
// Export a normalize(input: string) function and update the places where user input is fed into buildPrompt() to call normalize() first.

• Add snapshot/golden tests and CI note (create tests/golden/\*.snap and tests/run-golden.md)

// Create tests/golden/README.md explaining the golden test process and how to update snapshots.
// Create tests/golden/example.snap with the approved canonical JSON responses for representative inputs.
// Create tests/run-golden.md that instructs developers how to run tests locally or in CI (outside Lovable):
// // This step requires running node/npm on a machine or CI runner. Use GitHub Actions to run snapshots on commits.
// // Example instruction: "Install deps and run `npm test`" — this is outside Lovable and must be executed via GitHub Actions or locally.

Quick checklist and runtime guidance

• Use Lovable Secrets UI — set API keys and, if you want, a MODEL\_NAME secret. Instruct Lovable to read process.env or your app's config to avoid hardcoding keys.
• Always set temperature to 0 for deterministic/precise JSON outputs — keep that in src/config/lm.ts and reference it everywhere.
• Use Preview to iteratively test prompts — iterate the template and examples until outputs match your schema in Preview before publishing.
• For CI, GitHub sync/export is required — any step that runs tests or installs packages is outside Lovable and must be done by syncing to GitHub and running Actions.