AI generating garbage? How to use DSPy to optimize prompts

The invisible problem behind handmade prompts

Anyone who has spent hours tweaking a sentence, changing a comma, or adding random examples into a text box knows how frustrating artificial intelligence development can feel. In practice, when building systems using large language models (LLMs), we rely on instructions written in natural language that work today but break tomorrow if the provider updates the underlying model version. This vicious cycle of manual testing generates friction, wasted time, and unstable code.

To make matters worse, as workflows grow and involve multiple chained calls, the maintenance cost of these text snippets explodes. If you need to change a conversational agent's behavior in production, tweaking a central prompt might misalign three other secondary tasks depending on that exact format. It is precisely to solve this structural fragility that we need to treat prompt design not as literary art, but as predictable, testable software engineering.

What is DSPy and why it changes the game

Created by researchers at Stanford University, DSPy (Declarative Self-improving Python) proposes a radical paradigm shift: instead of writing extensive prompts full of textual tricks, you define declarative signatures and let the framework figure out the best instruction text for you. In practice, DSPy acts as a compiler for artificial intelligence, where you declare what the input should produce as output, and the system optimizes it programmatically based on evaluation metrics.

This means that instead of guessing whether saying " please" improves the model's response, the DSPy compiler runs dozens of automated tests using your validation data to find the ideal combination of examples and instructions. This process closely resembles how a database query optimizer chooses the best execution plan for a heavy SQL query, lifting the analytical burden off the developer's shoulders and ensuring greater systemic resilience.

How to structure signatures and modules in code

The basic building block in DSPy is the signature, which typed-defines the expected input and output fields of a computational task. To understand how this applies in practice, we can look at a Python example where we create a simple module to summarize technical documents and extract key points without writing a single line of complex text instructions.

import dspy

# Configure the default language model
llm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=llm)

# Define a typed signature for the task
class TechnicalSummarizer(dspy.Signature):
    """Summarize a technical article and extract the three main conclusions."""
    document = dspy.InputField(desc="Full article text")
    conclusions = dspy.OutputField(desc="List with three main conclusions")

# Create the functional module using the signature
class ArticleProcessor(dspy.Module):
    def __init__(self):
        super().__init__()
        self.summarize = dspy.Predict(TechnicalSummarizer)
        
    def forward(self, document):
        return self.summarize(document=document)

In the code above, the TechnicalSummarizer class establishes a clear contract of what goes in and out, while the ArticleProcessor module encapsulates execution. If in the future we decide to migrate to another AI provider or an open-source model running locally, we won't need to rewrite any prompts scattered across the codebase; we just need to change the base configuration, as DSPy will dynamically adjust the communication interface.

The power of optimizers and automatic compilation

The true magic of the DSPy ecosystem happens when we use optimizers (formerly known as teleprompters). Optimizers like BootstrapFewShot analyze your training dataset and select the best examples to inject into the model's context dynamically, ensuring the LLM receives the exact support needed to get the answer right without wasting unnecessary tokens.

In practice, this means your artificial intelligence system improves autonomously as you feed the pipeline with new validated examples. To ensure these outputs remain reliable and hallucination-free before reaching the end user, many teams combine this programmatic compilation with additional mechanisms, as discussed in strategies to validate model outputs with structured guardrails. To complement this implementation in production environments, see our related technical analyses on Microservices freezing? How to use the Orchestrated Saga and Database connection leaks? How to use PgBouncer in Node.js.

Final thoughts on modern prompt engineering

Abandoning guesswork-based prompt engineering and adopting a declarative approach with DSPy represents a maturity leap for any team developing AI-powered applications. We stop being hostages to unstable manual tweaks and start treating prompts as compilable, versionable artifacts capable of undergoing rigorous automated testing.

Investing time in structuring signatures and using programmatic optimizers drastically reduces operational costs and increases system predictability in production. As models continue to evolve, tools that abstract textual complexity and bring traditional engineering rigor to the LLM ecosystem will cease to be a differentiator and become the market standard.