What is the core difference between declarative frameworks (DSPy, BAML) and imperative ones (LangChain, LlamaIndex) in terms of what the developer writes and what the framework produces?

There are two big families of LLM frameworks. The imperative family includes LangChain and LlamaIndex. The declarative family includes DSPy and BAML. In an imperative framework, you write the prompt yourself. You compose it from templates, you decide what context to include, and you wire the steps together with code that says do this, then this, then this. The framework's job is to run what you wrote and give you the result. In a declarative framework such as DSPy, you do not write the prompt. You write a signature: a description of what goes in and what comes out, plus short hints about what each field means. You also write a metric that scores the output against a labeled dataset. The framework then runs an optimizer that tries many prompt variants and few-shot examples, keeps the ones that score best on your metric, and ships that prompt. Declarative wins when you have labeled data and want the prompt to improve automatically. Imperative wins when you need to see and edit the exact text the model sees.

The split is between writing the prompt and writing the spec. LangChain and LlamaIndex are imperative: the developer authors prompts, decides how to chain steps, and wires the flow with explicit code. The framework's job is execution and composition glue. DSPy and BAML invert that. In **DSPy**, the developer writes a Signature like `question, context -> answer` with a docstring describing what each field means, plus a metric over a small labeled set. The framework's compile step runs an optimizer, `BootstrapFewShot`, `MIPROv2`, `COPRO`, that searches over prompt variants and few-shot exemplar selections, scores each candidate with the metric, and selects the winner. The final prompt the model sees is generated, not authored. BAML is declarative on a different axis: schema-first codegen. You write a typed function definition, including its prompt template, in BAML's DSL, and the toolchain generates a Python or TypeScript client plus the runtime parsing logic. The output-format part of the prompt is generated from the schema, and type errors in calling code are caught at compile time. The tradeoff is real. Declarative tools trade step-level debuggability for automatic optimization and type-safety. Imperative tools trade optimization for the ability to see and tweak the exact text the model receives. Most production teams mix the two: imperative for the chain backbone, declarative pockets where they have labeled data and want the prompt to keep improving.