# Prompt Engineering Applications in the dair-ai Guide: Data Generation, PAL, and Notebooks

> Explore prompt engineering applications like synthetic data generation, Program-Aided Language Models PAL, and interactive notebooks in the dair-ai guide. Learn practical techniques.

- Repository: [DAIR.AI/Prompt-Engineering-Guide](https://github.com/dair-ai/Prompt-Engineering-Guide)
- Tags: tutorial
- Published: 2026-03-03

---

**The dair-ai Prompt-Engineering-Guide repository documents three practical prompt engineering applications: synthetic training data generation, Program-Aided Language Models (PAL) for executable reasoning, and interactive Jupyter notebook implementations.**

The **dair-ai/Prompt-Engineering-Guide** repository serves as a comprehensive resource for practitioners implementing large language model (LLM) techniques in production workflows. Central to its practical guidance is the [`guides/prompts-applications.md`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md) file, which catalogs specific **prompt engineering applications** that bridge theoretical techniques with executable code. These documented use cases demonstrate how structured prompting strategies automate data creation, augment reasoning with external tools, and facilitate hands-on experimentation.

## Generating Synthetic Data with Prompt Engineering

The repository details how LLM prompts can function as data generators, eliminating manual annotation bottlenecks. Located in the [`#generating-data`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md#generating-data) section of [`guides/prompts-applications.md`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md), this application demonstrates creating labeled datasets through few-shot prompting.

The guide provides concrete examples for sentiment analysis annotation:

```text
Prompt:
Produce 10 exemplars for sentiment analysis. Examples are categorized as either
positive or negative. Produce 2 negative examples and 8 positive examples.
Use this format for the examples:
Q: <sentence>
A: <sentiment>

```

**Expected output format:**

```text
Q: I just got the best news ever!
A: Positive

Q: The weather outside is so gloomy.
A: Negative

```

This technique extends beyond simple classification. The documentation references JSON-formatted wine-review annotations, showing how prompts can generate structured data schemas suitable for downstream machine learning pipelines.

## Program-Aided Language Models (PAL) for Tool-Augmented Reasoning

The second major application, documented under [`#pal-program-aided-language-models`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md#pal-program-aided-language-models), implements **Program-Aided Language Models (PAL)**. This approach prompts the LLM to emit executable Python code rather than direct text answers, outsourcing calculation and logic to an interpreter.

The repository provides a complete implementation using LangChain and OpenAI models:

```python
import openai
from datetime import datetime
from dateutil.relativedelta import relativedelta
import os
from langchain.llms import OpenAI
from dotenv import load_dotenv

# Load API key

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

# Initialize model

llm = OpenAI(model_name='text-davinci-003', temperature=0)

# PAL-style prompt template

question = "Today is 27 February 2023. I was born exactly 25 years ago. What is the date I was born in MM/DD/YYYY?"
DATE_UNDERSTANDING_PROMPT = """

# Q: 2015 is coming in 36 hours. What is the date one week from today in MM/DD/YYYY?

...

# Q: {question}

""".strip() + '\n'

# Generate and execute program

llm_out = llm(DATE_UNDERSTANDING_PROMPT.format(question=question))
exec(llm_out)  # Executes the generated Python code

print(born)    # Outputs: 02/27/1998

```

This pattern addresses LLM limitations in arithmetic and date reasoning by combining natural language understanding with deterministic code execution. The `exec()` call runs the Python script generated by the model, separating semantic parsing from computational logic.

## Python Notebooks for Hands-On Prompt Engineering

The third application area aggregates executable resources in the [`#python-notebooks`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md#python-notebooks) section. Rather than theoretical descriptions, this section provides a curated table of Jupyter notebooks that implement the aforementioned techniques.

Key resources include:

- **Program-Aided Language Models Notebook**: Located at `notebooks/pe-pal.ipynb`, this file contains the executable PAL workflow combining LangChain integration with OpenAI API calls.

These notebooks enable immediate experimentation with the repository's **prompt engineering applications**, allowing developers to modify parameters and observe output changes in real-time.

## Summary

- **Synthetic Data Generation**: Uses structured prompts to create labeled training examples (sentiment analysis, JSON annotations) without manual annotation, documented in [`guides/prompts-applications.md`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md).

- **Program-Aided Language Models (PAL)**: Offloads reasoning tasks to Python interpreters by prompting LLMs to generate executable code, implemented with LangChain and demonstrated through date-understanding examples.

- **Interactive Notebooks**: Provides executable Jupyter notebooks (`notebooks/pe-pal.ipynb`) that bundle these techniques into reproducible experimentation environments.

## Frequently Asked Questions

### What are the main prompt engineering applications covered in the dair-ai repository?

The repository covers three primary applications: generating synthetic training data through structured prompting, implementing Program-Aided Language Models (PAL) that generate executable Python code for complex reasoning, and providing interactive Python notebooks for hands-on experimentation. These are centrally documented in [`guides/prompts-applications.md`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md).

### How does the PAL (Program-Aided Language Models) application work in practice?

PAL works by prompting the LLM to write Python code rather than answering directly. In the repository's example, the model receives a date-understanding question and outputs Python script using `datetime` and `dateutil` libraries. The user then executes this code via `exec()` to obtain a computationally accurate answer, bypassing the LLM's inherent calculation limitations.

### Can I run the prompt engineering examples locally?

Yes. The repository provides executable Jupyter notebooks in the `notebooks/` directory, specifically `notebooks/pe-pal.ipynb` for the PAL implementation. The code examples use standard Python libraries including `langchain`, `openai`, and `dateutil`, requiring only an OpenAI API key set via environment variables as shown in the `load_dotenv()` pattern.

### Where is the applications documentation located in the repository?

The primary documentation resides in [`guides/prompts-applications.md`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-applications.md) at the repository root. This file contains the three application sections (Generating Data, PAL, and Python Notebooks) with embedded code examples and links to supplementary files like [`guides/prompts-reliability.md`](https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/guides/prompts-reliability.md) and the executable notebook files.