omidzamani/dspy-skills

dspy-better-together

Use for BetterTogether, prompt plus weight optimization, fine-tuning sequences, and strategy chains like p -> w -> p.

First seen Jun 12, 2026

Installation

$ npx skills add omidzamani/dspy-skills --skill dspy-better-together

Also in this package

Other skills from omidzamani/dspy-skills · top by installs.

npx skills add omidzamani/dspy-skills

Browse all from omidzamani/dspy-skills

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Repository health

Stars 121
License LICENSE
Default branch master
Open issues 1
Status Active

Skill metadata

Parsed from SKILL.md frontmatter.

Version1.0.0
Allowed toolsRead, Write, Glob, Grep

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 3,021 B
  • docs SUMMARY.md 145 B

History

  1. First seen on skills.sh
  2. First recorded snapshot · 6 installs

SKILL.md

DSPy BetterTogether

Goal

Sequence prompt and weight optimizers, evaluate intermediate programs, and return the best candidate.

Prerequisites

  • Use DSPy 3.2.1 or later in the stable 3.2.x series.
  • Assign an LM directly to every predictor with student.set_lm(lm).
  • Keep a validation set, or allow BetterTogether to hold out part of the trainset.
  • Confirm the LM provider supports fine-tuning before including BootstrapFinetune.

Basic Pattern

import dspy

lm = dspy.LM("openai/gpt-4o-mini")
dspy.configure(lm=lm)

student = dspy.ChainOfThought("question -> answer")
student.set_lm(lm)

def metric(example, pred, trace=None):
    return float(example.answer.lower() == pred.answer.lower())

optimizer = dspy.BetterTogether(
    metric=metric,
    p=dspy.GEPA(
        metric=lambda gold, pred, trace=None, pred_name=None, pred_trace=None:
            dspy.Prediction(score=metric(gold, pred), feedback="Check answer correctness."),
        reflection_lm=dspy.LM("openai/gpt-4o"),
        auto="light",
    ),
    w=dspy.BootstrapFinetune(metric=metric),
)

compiled = optimizer.compile(
    student,
    trainset=trainset,
    valset=valset,
    strategy="p -> w -> p",
)

Strategy Choices

Strategy Use it when
"p -> w" Start with a simple prompt-then-weight pass
"p -> w -> p" Re-optimize prompts after fine-tuning
"w -> p" Fine-tuning data is already strong
Custom chains Comparing prompt optimizers or conducting controlled experiments

Optimizer names come from constructor keyword arguments. For example, mipro=... and gepa=... make "mipro -> gepa" valid.

Per-Optimizer Compile Arguments

Pass optimizer-specific arguments through optimizercompileargs:

compiled = optimizer.compile(
    student,
    trainset=trainset,
    valset=valset,
    strategy="p -> w",
    optimizer_compile_args={
        "p": {"max_metric_calls": 150},
    },
)

Do not pass student inside optimizercompileargs; BetterTogether manages the current program.

Inspect Results

The returned program exposes:

  • candidate_programs: evaluated candidates with score and strategy
  • flagcompilationerror_occurred: whether a step failed before completion

Related Skills

  • Pick optimizers: [dspy-optimizer-selection](../dspy-optimizer-selection/SKILL.md)
  • Fine-tune weights: [dspy-finetune-bootstrap](../dspy-finetune-bootstrap/SKILL.md)
  • Reflect with GEPA: [dspy-gepa-reflective](../dspy-gepa-reflective/SKILL.md)

Official Documentation