How to Build Reusable Prompts for Local LLMs

TL;DR

Effective prompt engineering starts with rapid experimentation, then turns successful instructions into structured, reusable assets. Store prompts in files, compare their outputs across hosted and local models, specify the purpose and output rules, and separate changing inputs from static instructions. XML structure can help organize complex prompts, while tools such as LLM and Ollama make model comparison accessible from the terminal.

Transcript

2025 is just a few clicks away AI agents are emerging Next Generation language models are right around the corner and Quinn 2.5 is proving that local models are no longer a Dream It's become absolutely clear to me that your success and My Success hinges on one thing among all the change over the past year one thing has stayed constant the f... Read More

Key Insights

• A level-one prompt is an ad hoc instruction used to explore model behavior quickly. Small additions such as Python, XML, or exclusively can change the requested language, output format, and amount of explanatory text without requiring an elaborate prompt structure.
• Prompt files are useful experimental assets because they can be edited once and redirected into command-line tools repeatedly. The demonstration stores instructions in prompt.txt, executes them through the LLM CLI or Ollama, and revises the same file as requirements change.
• Cross-model testing is a practical way to evaluate prompt reliability. Running one prompt against Gemini, OpenAI, Claude, Llama 3.2, and Qwen 2.5 Coder exposes differences in formatting, precision, and compliance while keeping the requested task constant.
• Small local models may not follow formatting instructions perfectly. The demonstrated Llama 3.2 1B configuration produces an imperfect result, while Qwen 2.5 Coder 14B produces a usable but still imperfect SQL table from the same simple input structure.
• Shell scripts can automate prompt comparison across several models. The demonstration creates many_models.sh with repeated LLM commands, each selecting a different model alias while redirecting the same prompt file, so outputs can be reviewed together under consistent conditions.
• A level-two prompt is a reusable solution for a well-defined, simple problem. It adds information that remains stable, including the prompt's purpose and instructions, while reserving a clearly marked variable section for input that changes between executions.
• XML provides explicit boundaries between prompt components. The demonstrated template uses separate sections for purpose, instructions, and the TypeScript interface, making the prompt easier to extend with new rules as the developer understands the conversion problem more deeply.
• Output constraints make generated code easier to reuse. Instructions such as using the PostgreSQL dialect and responding only with a table definition reduce unwanted explanation, while changing the interface block allows the same prompt to generate definitions for users, avatars, and other tables.

Questions & Answers

Q: How can engineers test the same prompt across LLMs?

Engineers can save an instruction in a text file and redirect that file into a command-line model tool. The LLM CLI accepts a selected model through its model option, while Ollama runs installed local models. Reusing the identical file with Gemini, OpenAI, Claude, Llama 3.2, or Qwen 2.5 Coder makes differences in output precision and instruction following easier to observe.

Q: What is a level-one prompt in prompt engineering?

A level-one prompt is a simple, ad hoc instruction used for quick exploration. The demonstration begins with ping, then changes the file to request counting from zero to ten and back. Adding brief terms such as Python or XML changes the response format. This level is valuable for rapidly testing ideas before converting a successful instruction into a reusable prompt asset.

Q: How do small prompt changes affect an LLM response?

Small prompt changes can determine the language, syntax, format, and amount of commentary in a response. Adding Python requests Python output, while adding XML requests an XML representation. Changing SQLite to PostgreSQL alters the expected database syntax. Adding exclusively tells the model to omit extra explanation and return only the requested table definition, although compliance still varies by model.

Q: Why should developers compare prompt outputs across models?

Developers should compare outputs because models do not interpret identical instructions with equal precision. The transcript shows a small Llama 3.2 1B model failing to follow every requirement, Qwen 2.5 Coder 14B producing an imperfect but useful result, and Claude 3.5 Haiku providing a precise response. Side-by-side testing helps expose these behavioral differences before a prompt is reused in an application.

Q: How can a shell script automate prompt evaluation?

A shell script can contain multiple LLM commands that each select a different model alias and redirect the same prompt file as input. Running the script executes the prompt across several models in sequence and prints their responses for comparison. This approach reduces repetitive command entry and supports quick evaluation whenever the prompt changes or a new model becomes available.

Q: What makes a level-two prompt reusable?

A level-two prompt separates stable problem-solving instructions from an input section that changes between uses. In the example, the purpose remains converting a TypeScript interface into a SQL table, and the rules continue to require PostgreSQL syntax and table-only output. The interface block can then be replaced with new fields, allowing one structured prompt to solve repeated versions of the same defined problem.

Q: Why does the demonstrated prompt use XML structure?

The demonstrated prompt uses XML to give clear boundaries to its purpose, instructions, and variable interface block. The presenter states that adding this structure generally improves performance as prompts become more complex and attributes that behavior to language models being trained on web content containing HTML, which is described as a subset of XML. The structure also makes additional instructions easier to insert and maintain.

Q: How do you create a reusable TypeScript-to-SQL prompt?

Define the prompt's purpose as converting a TypeScript interface into a SQL table, then add explicit rules such as using the PostgreSQL dialect and returning only the table definition. Place the changing TypeScript interface inside a distinct interface block and save the full structure as a reusable XML file. For another table, update the interface fields while preserving the established purpose and formatting instructions.

Summary & Key Takeaways

• The first framework level uses simple, ad hoc prompts to explore how wording changes model behavior. Adding terms such as Python, XML, exclusively, or a database dialect can substantially alter the response. Saving the prompt in a text file makes repeated terminal testing fast and keeps the experiment easy to modify.

• The LLM CLI and Ollama support rapid prompt prototyping across hosted and local models. A single prompt can be tested with Gemini, OpenAI, Claude, Llama 3.2, and Qwen 2.5 Coder configurations. Comparing responses reveals differences in instruction following, precision, formatting, and the capabilities associated with model size.

• The second framework level converts an effective experiment into a reusable prompt for a defined problem. The demonstrated XML structure separates purpose, instructions, and a variable interface block. Static rules specify PostgreSQL syntax and table-only output, while the TypeScript interface changes whenever a new SQL table definition is required.