Identify the conditions under which the 'no framework' (raw SDK) pattern is the better choice, select all that apply

Multi-select·Medium·4.0 · 0·~1 min·Asked atPerplexity Sharechat Workday

Attempt it

The 'no framework' pattern means using the raw provider SDK (the `openai` package, the `anthropic` package, the Vercel `ai` package's core primitives) and writing your own composition logic. It is not always wrong; in specific conditions it is the better choice. **Conditions where raw SDK wins (the correct answers):** - **Small surface.** One or two prompts with no composition. The framework would add tax without absorbing real work. - **Day-one provider feature.** When OpenAI ships a feature (caching, computer use) and you need it this week, the framework wrapper is 4-8 weeks behind; you write the raw call anyway. - **Tight latency.** Framework dispatch adds milliseconds; on a hot path with a sub-100ms budget, the overhead matters. - **Small team.** A two-engineer team can carry a hand-rolled composition layer in their heads; a framework's vocabulary is overhead they do not need. **Conditions where the framework wins (the wrong answers):** - **12-agent system with routing and HITL.** This is exactly the composition complexity a framework absorbs. Rebuilding LangGraph's state-machine and checkpointer from scratch would be months of work. - **Regulatory observability.** This is a reason to add OpenTelemetry, not a reason to drop the framework. The two concerns are independent; you can have a framework with OTel observability, or no framework with OTel observability.

**The pattern: match the framework decision to the shape of the work.** No-framework is a sharp pick in four scenarios, the wrong pick in two. **Where no-framework wins:** 1. **Single-prompt or two-prompt products.** Framework value is composition; without composition there is no value to extract. Raw SDK is faster to write, smaller to ship, easier to debug. 2. **Day-one provider features.** Wrapper lag (4-8 weeks) means urgent features get written as raw-SDK bypasses anyway. Better to start there than maintain both paths. 3. **Hard latency budgets.** Framework dispatch overhead is measurable. On a sub-100ms hot path (autocomplete, real-time scoring), the overhead can blow the budget. 4. **Small teams without need for a shared composition vocabulary.** A two-engineer team can carry a hand-rolled composition layer in their heads. **Where the framework wins:** - **12-agent system with tool-routing, supervisor logic, and HITL interrupts.** The textbook composition-complexity case. LangGraph's State + Node + Edge plus checkpointer absorb hundreds of lines of state-machine code. Rebuilding from scratch is months of work. - **Observability as a regulatory requirement.** Orthogonal to framework choice. The right response is to wire OpenTelemetry; you can do that with a framework or without one. Dropping the framework does not solve the observability problem; adding OTel does. **The senior insight.** The question is not 'frameworks good or bad?' It is 'does this problem need the composition primitives a framework provides?' Four options describe problems that do not; two describe problems that do.

TL;DR

Raw SDK wins on small surface, urgent provider features, tight latency, and small teams; loses on complex multi-agent systems; observability requirements are an independent axis.

Memory aid

Easy to grasp

Picture choosing between a Swiss Army knife and a single sharp kitchen knife. The Swiss Army knife is great when you need 10 different tools because each one is right there and you do not have to carry 10 separate items. The kitchen knife is great when you only need to chop one thing, when you need the absolute sharpest edge, or when you want to be in and out fast. Neither is universally better; the right pick depends on the job. The raw SDK is the kitchen knife; the framework is the Swiss Army knife.

Key concepts

LLM frameworks

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

The 'no framework' (raw SDK) pattern is the most under-credited architectural choice in 2026 LLM engineering. Junior engineers often default to a framework because the tutorials they read use frameworks; senior engineers know the framework is a finite-term lease and that for some surfaces the lease never pays for itself. The question is not whether to use a framework in general but whether to use one for this specific surface, on this specific timeline, with this specific team.

This multi-select question tests exactly that judgement. Four of the conditions are framework-tax cases where raw SDK wins; two are framework earn its keep cases where the framework's primitives absorb work that raw SDK would force you to hand-roll. Candidates who can name why each condition falls into its bucket demonstrate the per-surface decision-making that separates framework-aware engineering from cargo-culted framework adoption.

This deep dive walks each correct option (why raw SDK wins there), each wrong option (why the framework wins instead), the relationship between framework choice and observability choice (which the wrong options conflate), and the production patterns that mix framework and no-framework surfaces in the same codebase.

Why one or two prompts wins for raw SDK

A framework's value proposition is composition: chaining prompts, retrievers, tools, and parsers into pipelines. When the surface is a single prompt or two independent prompts, there is no composition to absorb. The framework's contribution is zero; the framework's tax (feature lag, type coupling, ejection cost, install size) is paid for no return.

Consider a product that runs one classification prompt per request: 'classify this support ticket into one of these 12 categories.' The raw-SDK version is: import openai; call client.chat.completions.create with a system prompt and the ticket text; parse the response. Maybe 20 lines. The LangChain version uses ChatOpenAI, a prompt template, an output parser, possibly an LCEL chain to wire them together. Maybe 50 lines, plus the install footprint of langchain plus langchain-openai plus their transitive dependencies.

The raw-SDK version is easier to write, easier to debug (fewer indirection layers), faster to ship to production (smaller install), and easier to test (no mocking of framework abstractions). The framework version offers consistency with a hypothetical future composition surface that may not arrive.

The diagnostic question: if the second engineer on this product needs to add a new prompt, will they think of it as 'add another LCEL chain' or as 'call the SDK with a different system prompt'? If the latter is the natural framing, the framework is overhead; if the former is the natural framing, the framework is paying off.

Why urgent provider features push toward raw SDK

Why tight latency budgets push toward raw SDK

Why small teams push toward raw SDK and why multi-agent pushes toward framework

Why observability is orthogonal and the mature production pattern

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Cursor's autocomplete reportedly uses raw provider SDK for the latency-critical path; the framework would add measurable overhead.
Linear's simple AI features (single-prompt summarisation, classification) use raw SDK; their multi-step issue-triage uses LangGraph.

What an interviewer would ask next. Try answering before peeking at the approach.

QWalk through a no-framework pattern for a RAG pipeline.

Use the openai SDK for the LLM call, the pinecone or qdrant client directly for retrieval, and write your own functions for chunking and prompt assembly. Wire OpenTelemetry spans manually around each call. The result is maybe 200 lines for a basic pipeline, with no framework dependency. It works fine until you need re-ranking, hybrid retrieval, or response-synthesizer modes, at which point LlamaIndex absorbs the work.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Reading 'observability is a regulatory requirement' as a vote for no-framework. The right answer is to wire OTel, which is a separate concern from framework choice.

60 second bullets to scan on the way to the call.

The four conditions under which raw SDK wins
The textbook conditions under which a framework earns its keep

Primary sources. Browse if you want the original framing.