AI Career Reality Check · LLM Skills
What You Actually Need to Learn About LLMs
Most people asking this question do not need to learn how to train a large language model. Training frontier models happens in a handful of well-funded labs. The jobs that are growing, in product companies, IT services and startups across India, are about building with LLMs: getting reliable output, connecting models to company data, measuring quality and keeping costs under control. That changes what you should study. Here is the order that makes sense.
Level 1: Concepts you must be able to explain
You do not need the maths in depth, but you need a correct mental model. In an interview you should be able to explain each of these in two or three sentences:
- Tokens. Models read and write tokens, which are word pieces, not words. Pricing, speed and context limits are all measured in tokens. Hindi and other Indian-language text often uses more tokens than the same meaning in English, which affects cost.
- Next-token prediction. An LLM generates text one token at a time by predicting what is likely to come next. This is why it can sound confident while being wrong.
- Context window. Everything the model can "see" in one request: instructions, conversation history, documents and its own answer.
- Temperature and sampling. Lower values make output more predictable; higher values make it more varied.
- Pretraining, instruction tuning and alignment. Why a base model behaves differently from a chat model.
- Hallucination. Why models produce plausible but false statements, and why grounding them in real documents helps.
- Embeddings. Vectors that represent meaning, so similar texts are close together. They power search and RAG.
For the architecture behind all of this, read the explainer on the "Attention Is All You Need" transformer paper once you are comfortable with the ideas above.
Level 2: Calling models from code
Prompting in a chat window is not the job skill. The job skill is calling a model from Python (or JavaScript) inside an application and handling what comes back. Learn to:
- Use at least one provider's API and SDK, plus one open-weight model run locally or through a hosted service, so you understand both options.
- Write clear system instructions and give examples in the prompt (few-shot prompting).
- Ask for structured output, such as JSON that matches a schema, and validate it in code instead of trusting it.
- Handle errors, timeouts, rate limits and retries.
- Track token usage and cost per request.
- Stream responses so users see text as it is generated.
Python basics are the real prerequisite here. If functions, dictionaries, JSON and HTTP requests are still shaky, fix that first.
Level 3: Evaluation, the skill most learners skip
How do you know your prompt change made things better and not worse? Teams that ship LLM features keep a test set of real inputs with expected results and run it after every change. A minimal version needs nothing beyond plain Python:
def call_llm(prompt: str) -> str:
# Replace with a real API call. This stub lets the script run.
return "refund" if "money back" in prompt.lower() else "other"
test_cases = [
{"text": "I want my money back for order 1182", "expected": "refund"},
{"text": "How do I change my delivery address?", "expected": "other"},
{"text": "Please send the money back to my UPI", "expected": "refund"},
]
def classify(text: str) -> str:
prompt = f"Classify this support message as 'refund' or 'other'.\nMessage: {text}\nLabel:"
return call_llm(prompt).strip().lower()
passed = sum(classify(c["text"]) == c["expected"] for c in test_cases)
print(f"{passed}/{len(test_cases)} passed")
With the stub, this prints 3/3 passed. With a real model, failures show you exactly which inputs broke. Grow the test set from real user messages, and add checks for format, refusals and length. For open-ended answers, teams also use human review or a second model as a grader, carefully. Being able to say "I measured it like this" puts you ahead of most applicants.
Level 4: Connecting models to data (RAG)
Most business uses need the model to answer from company documents it was never trained on: HR policies, product manuals, past tickets. Retrieval-augmented generation (RAG) finds the relevant passages and puts them into the prompt. You need to learn chunking, embeddings, a vector database or vector index, retrieval quality and citing sources. This is a big enough topic to have its own guide: RAG as a career skill. The background on how RAG models improve accuracy is also useful.
Level 5: Tools and agents
Tool calling lets a model request an action, such as "look up order 1182", which your code performs and returns. Agents chain several such steps. Learn the basic loop first, then a framework if you need one; frameworks such as LangGraph or AutoGen make more sense once you have built a simple loop by hand. Focus on limits and safety: what the agent is allowed to do, how many steps it can take, and when a human must approve.
Level 6: Fine-tuning and deployment, when needed
Fine-tuning (including parameter-efficient methods such as LoRA) helps when you need a consistent style or format, or a smaller, cheaper model for a narrow task. It is usually not the first fix; better prompts and RAG solve many problems faster. Learn it after the earlier levels, along with deployment basics: serving an open model, caching, latency, monitoring and handling personal data responsibly.
What you can skip at first
| Can wait | Why |
|---|---|
| Training an LLM from scratch | Needs compute and data far beyond individual learners; few jobs require it |
| Deriving attention maths by hand | Useful later; a conceptual understanding is enough to build applications |
| Collecting "prompt packs" | Specific tricks age quickly; principles and evaluation last |
| Every new framework | Learn one well; the underlying patterns transfer |
| Benchmark leaderboards | Your own test set on your own task matters more than general rankings |
Turning this into proof for employers
Build one project per level from 2 onwards: a structured-output extractor (for example, pulling fields from invoices), a measured prompt-improvement write-up, a RAG assistant over a public document set such as a government scheme FAQ, and a small tool-using agent with clear limits. Document what failed and how you fixed it. That is the honest evidence hiring managers look for.
Frequently asked questions
Do I need machine learning before learning LLMs?
For building applications, strong Python and software basics matter more at first. ML fundamentals such as overfitting, evaluation metrics and embeddings become important as you go deeper, especially for fine-tuning and evaluation.
Is prompt engineering a career on its own?
It is increasingly part of other roles, such as AI engineer, ML engineer, or product and content roles, rather than a separate title at most companies. Treat it as one skill within building LLM applications.
Which LLM should I learn on?
Any major hosted model plus one open-weight model is enough. The concepts, API patterns and evaluation habits carry over when you switch.