Walk through the four lock-in costs a framework imposes on a production codebase and how each one compounds over time

**Adopting an LLM framework** is faster than the no-framework path on day one and slower to leave on day three hundred. The four costs to write up: - **Type coupling.** Your handlers, DI containers, and tests start holding framework types (Runnables, AgentExecutor, ChatPromptTemplate). Every new endpoint adds more places that import the framework, and the rewrite on ejection scales with the surface area. - **Prompt portability.** Prompts get expressed in framework primitives (ChatPromptTemplate, FewShotPromptTemplate, output parsers). Moving to a raw SDK means re-expressing every prompt in plain strings. A multi-day chore per chain, and the chore grows with every prompt you write. - **Observability vendor coupling.** Picking LangSmith means committing to LangChain because LangSmith primarily sees LangChain traces. Picking Langfuse or OpenTelemetry keeps you portable. The choice often gets made on a free tier or brand familiarity, then compounds quietly. - **Feature lag.** When OpenAI or Anthropic ships a new capability (prompt caching, structured outputs, computer use), the wrapper takes 4 to 8 weeks to expose it. The lag is per-feature, and it accumulates when you are waiting for two or three at once. None of these blocks anything on its own. The compounding is the cost, because each one makes the others harder to fix later.

**Four costs compound, and the compounding is the argument.** **Type coupling.** Day one: a few imports of `RunnableSequence` or `AgentExecutor`. Month twelve: handler signatures, DI containers, and integration tests are typed against framework objects. Removing the framework means rewriting every signature, every fixture, every wrapper that returned a `Runnable`. The rewrite scales with the code surface that ever touched a framework type. **Prompt portability.** Day one: a few `ChatPromptTemplate.from_messages` calls. Month twelve: prompts are expressed in framework primitives. FewShotPromptTemplate, output parsers, partial-variable composition. Moving to a raw SDK means re-expressing every prompt, a multi-day chore per chain, multiplied by chain count. **Observability vendor coupling.** LangSmith is the canonical example: it sees LangChain traces natively, anything else second-class. Picked on day one for the wrong reasons (free tier, brand), by month twelve your dashboards, alerts, and runbooks assume LangSmith. The hedge is OpenTelemetry plus a vendor-agnostic backend like Langfuse. **Feature lag.** Providers ship features (prompt caching, structured outputs, computer use) on their cadence; wrappers expose them 4 to 8 weeks behind. Day one you wait once. Month twelve you wait on three at once while a raw-SDK competitor has shipped. None is a blocker alone. Frameworks earn their keep on the right problems. The four costs interact: types make prompt rewrites harder, vendor coupling makes observability migration its own project, lag accumulates while ejection is hard. Adopt deliberately, hedge with OTel, keep critical paths on thin wrappers.