# LLMs for Intent Classification: Why You Don’t Need a Full ML Team

URL: https://dcrewe.com/article/llms-for-intent-classification_-why-you-dont-need-a-full-ml-team  
Author: Donovan Crewe  
Published: 2025-08-21  
Categories: Natural Language Processing, Machine Learning, Artificial Intelligence, Prompt Engineering, Customer Support, Conversational AI

> The rise of large language models (LLMs) has transformed intent classification, making it possible to achieve production-quality results without a full machine learning team or the need to train a model from scratch. The article explains how prompt-driven classification, using zero-shot or few-shot examples, offers a faster, more flexible, and more cost-effective alternative to traditional, data-heavy ML pipelines. It also addresses engineering considerations such as latency, ambiguity, cost, and evaluation, while highlighting how this approach is already being used successfully in various fields.

Intent classification has long been a core task in natural language processing (NLP). Whether you’re routing support tickets, sorting sales inquiries, or powering conversational assistants, understanding what a user wants is fundamental to delivering the right response.

Historically, solving this problem meant building a full-blown machine learning pipeline from scratch. Teams had to collect and label thousands of examples, train and deploy a model, then retrain it regularly as the data evolved. It worked, but it was slow, brittle, and expensive. The process demanded deep ML expertise, a rock-solid data pipeline, and significant ongoing investment. And even then, improvements took time to reach the end user due to long feedback loops.

But the rise of large language models (LLMs) like GPT-5, Claude 4, and open-weight models such as gpt-oss have transformed the landscape. Today, you can achieve production-quality intent classification without ever training a model. Instead of building infrastructure from scratch, you use prompts. Instead of worrying about model maintenance, you focus on delivering value.

This isn’t just about convenience. It’s a shift in the economics and speed of building intelligent systems, a shift that empowers teams of all sizes, especially those without a dedicated machine learning department.

## **The Problem with Traditional Intent Classification**

Imagine you run a SaaS product and want to classify incoming support messages into categories like **Billing**, **Tech Support**, or **Sales**. The classic ML approach might look like this:

1. Collect thousands of past messages from customers.

2. Label each one manually, creating a training dataset.

3. Train a model, maybe a BERT variant or an SVM.

4. Tune hyperparameters to maximize accuracy.

5. Deploy the model to production.

6. Monitor performance and retrain every time you add new categories or see accuracy drop.

This approach locks you into rigid categories and a constant cycle of labeling, training, and testing. Want to add a new intent? You’re back to square one. Expanding to new languages? That’s another mountain of data. Every iteration costs time, money, and people, usually ML engineers and data scientists who could be working on more strategic problems.

## **LLMs Change the Game**

Modern LLMs are trained on vast and diverse data. They already understand language well enough to infer intent from context and even without task-specific training. Instead of collecting and labeling massive datasets, you can simply provide a clear instruction and a few well-chosen examples.

#### **Prompt-Driven Classification**

Here’s an example:

“Given the following message, classify the user’s intent as one of: Billing, Technical Support, Cancellation, Sales Inquiry, or Other.”

Then you add a few examples:

- *Message:* I need help updating my payment method. *Intent:* Billing
- *Message:* My account got locked after the update. *Intent:* Technical Support
- *Message:* Can someone walk me through the enterprise pricing tiers? *Intent:* Sales Inquiry

Once the pattern is established, you append a new message and the LLM infers the correct intent, often matching or surpassing the accuracy of traditional models without months of setup.

## **Zero-Shot, Few-Shot, or Fine-Tuned?**

The flexibility of LLMs lies in how you deploy them. You can start with zero-shot prompting, add a few examples as needed, and later fine-tune if your use case demands it.

#### **Zero-Shot Classification**

In this approach, the LLM receives only the instruction and the list of categories with no examples. Surprisingly, it often performs well for general categories. For example, classifying “Please cancel my subscription” as “Cancellation” works nearly every time.

Accuracy: ~85–90%
Setup time: Minimal
Best for: Internal tools, early-stage prototypes, rapid iteration

#### **Few-Shot Classification**

You embed a handful of examples into the prompt. This provides context and helps the model handle domain-specific language, abbreviations, or ambiguous phrasing.

Accuracy: ~90–95%
Setup time: Light curation
Best for: Production workflows, moderate complexity, small teams

#### **Fine-Tuned Classification**

You train the model further using your own labeled data. This provides maximum control and performance but requires compute resources and ML expertise. It’s best reserved for situations where the cost of error is high (e.g., healthcare triage, financial compliance) or you need consistent behavior at scale.

Accuracy: Up to 97%
Setup time: High
Best for: Regulated environments, long-term stability, multilingual support

With this progressive comparison, it’s easy to get started small and tailor a solution that scales in both accuracy and implementation effort as your needs grow. Most companies today start with few-shot prompting. It offers the best mix of speed, simplicity, and quality, and it gives you a clear path to scaling or fine-tuning later if needed.

## **Engineering Considerations**

LLMs are powerful, but they’re not magic. To make them work reliably in production, you’ll need to think about performance, reliability, and cost from day one.

**Latency** is often the first trade-off teams notice. Unlike traditional classifiers that return results in milliseconds, a LLM, especially when fed a large prompt can take longer to respond. The good news is there are ways to mitigate this: cache repeated messages so you’re not paying for the same classification twice, route high-volume but low-risk cases to lighter models like `gpt-4o-mini`, and even use simple rules to pre-classify the most obvious cases before involving the LLM.

Ambiguity is another reality. No model, however advanced, will always be 100% certain. That’s why **fallbacks and confidence handling** matter. You might return the top two intents for review, add a catch-all “Other” or “Uncertain” category, or keep a human-in-the-loop for high-stakes cases. This not only improves reliability but also builds trust in the system for your end users.

Then there’s **cost**. Token usage can add up surprisingly fast, especially if you’re processing long messages or embedding multiple few-shot examples. The key is to trim the fat: truncate overly long inputs, compress your examples, and experiment with leaner prompts. If usage grows significantly, you can distill your workflow into a smaller fine-tuned model or use quantization techniques to lower compute requirements.

Finally, never skip **evaluation**. Just because a classification pipeline is prompt-based doesn’t mean you can ignore QA. Regular synthetic tests can help you spot regressions early. Human spot checks can catch subtle errors. Monitoring intent distribution drift over time keeps the system aligned with real-world usage. And logging outputs allows you to quickly identify recurring misclassifications and update your prompts accordingly.

## **Where It’s Working Now**

The results speak for themselves.

In **customer support**, LLMs are classifying and routing tickets instantly, getting users to the right team without the back-and-forth.
In **sales pipelines**, they’re parsing chat transcripts and lead forms to flag high-intent buyers before a human ever steps in.
In **conversational UIs**, they’re turning natural language into precise app commands eg. “Show me last month’s revenue vs. forecast” becomes a data query in seconds.
In **call centers**, they’re converting voice-to-text transcripts into structured intents so the next available agent has full context.

What’s striking is the speed of deployment. These aren’t months-long projects. Teams are standing them up in hours or days, then iterating in real time not by retraining models, but by tweaking prompts and business logic. That kind of agility is why LLM-based intent classification is quickly becoming the default approach for forward-thinking teams.

## **What You Really Need**

Building a production-ready intent classification system today doesn’t require an army of machine learning engineers, a bespoke model, or a sprawling MLOps pipeline. Those used to be the prerequisites, the price of admission for doing NLP at scale.

Now, the toolkit is refreshingly lean. All you need is a capable LLM whether it’s GPT-5, Claude 4, or an open-weight model like gpt-oss paired with a well-crafted prompt that clearly defines your categories and includes a few high-quality examples. Wrap that with a bit of glue code to manage inputs, outputs, caching, and logging, and you’re in business.

This shift has levelled the playing field. Startups with lean engineering teams can now deploy intent classification systems that compete with, and in some cases outperform, those built by mature data science organizations and they can do it in days instead of months. The barriers are gone; what remains is the opportunity to focus on product value rather than infrastructure upkeep.

## **Final Thoughts**

Intent classification is no longer a heavyweight task. With LLMs, it’s fast, flexible, and remarkably effective  even for complex domains. For most teams, the ROI is clear: you get better results, faster, without the baggage of traditional ML workflows.

This doesn’t mean classic models are obsolete, they still have a place at scale and in regulated contexts. But for 80% of use cases, prompt-based LLM classification is a smarter, leaner bet. The path forward is clear: start small, iterate quickly, and let the model’s flexibility grow with your business needs.
