Click any module to expand. This is NOT a "what is ChatGPT?" overview — it's a structured training with 10 prompt techniques, role-specific workflows, and hands-on exercises comparing multiple AI models. Every subtopic includes practical examples and exercises.
What large language models actually do, their capabilities, and their limitations
LLMs are next-word prediction engines trained on massive text. They don't "think" or "understand" — they predict the most likely next word given previous words. GPT-4 was trained on trillions of words from books, websites, and code. This prediction, repeated thousands of times, produces coherent text, working code, and analysis. Understanding this removes the mystique: it's a very sophisticated autocomplete, not a sentient being.
LLMs process TOKENS (word fragments), not words. "Tokenisation" → ["Token", "isation"]. English: ~1 token per 0.75 words. Why it matters: context window limits are in tokens, API pricing is per token, and Hindi uses 2–3x more tokens than equivalent English. Try OpenAI's tokeniser tool to see how your text splits. Every prompt engineer must think in tokens, not words.
Context window = how much text the model can "see" at once (prompt + response). GPT-4o: 128K tokens (~96,000 words). Claude: 200K tokens. Gemini: 1M+. Bigger ≠ better — models perform worse on information in the MIDDLE of long contexts ("lost in the middle" problem). Practical: can you paste an entire document? Depends on context window. Will it remember page 1 when on page 50? Maybe not reliably.
Temperature 0 = deterministic (same input → same output, best for factual tasks). Temperature 0.7 = balanced (good for most tasks). Temperature 1.0 = creative (varied responses, best for brainstorming). Top-K: consider only K most likely next tokens. Top-P (nucleus): consider tokens whose cumulative probability exceeds P. Understanding these turns "the AI gives random answers" into "I control the AI's creativity."
Hallucinations = factually incorrect statements delivered with complete confidence. Why: the model predicts plausible-SOUNDING text, not TRUE text. Types: fabricated facts, non-existent citations, wrong code, invented statistics. Detection: ask for sources and verify, cross-check critical facts, use "say I don't know" instructions. LLMs are NOT knowledge bases — they're language engines. Using them as fact databases guarantees errors.
GPT-4o (OpenAI): strong all-around, good coding, 128K context. Claude (Anthropic): best for long documents, strong reasoning, 200K context, safety-focused. Gemini (Google): multimodal (text + image + video), 1M+ context. Open-source: LLaMA, Mistral, Phi — run locally, no API costs, full privacy. No single "best" — there's the best model FOR YOUR USE CASE. Compare on your specific task before committing.
Chat (ChatGPT, Claude.ai): manual, one-at-a-time, good for exploration. API: programmatic access, batch processing, application integration, custom parameters. When API matters: processing 1000 documents, building a chatbot, automating workflows. Cost: GPT-4o ~$2.50/1M input tokens. For students: chat for learning, API understanding for job readiness.
Cannot access real-time information (unless search-enabled). Has a knowledge cutoff date. Cannot perform true reasoning (pattern matching, not logic). Confidently wrong (no self-awareness of errors). Sensitive to prompt phrasing (small changes → different outputs). Privacy risk (inputs may be used for training on free tiers). Not deterministic (same prompt → different results). Cannot verify its own outputs. Knowing limitations is as important as knowing capabilities.
The techniques that turn vague AI responses into precise, reliable outputs
Five-part framework: (1) ROLE — who the AI should be, (2) CONTEXT — background information, (3) TASK — what to do, (4) FORMAT — how to structure output, (5) CONSTRAINTS — what NOT to do. Bad: "Write about marketing." Good: "You are a senior digital marketing strategist. A D2C skincare brand with ₹5L/month budget wants to increase Instagram engagement by 30% in 3 months. Create a monthly content calendar as a table. Keep budget-conscious."
Give the task with no examples. Works for unambiguous tasks: "Translate to Hindi: [text]", "Summarise in 3 bullets: [email]", "Classify as positive/negative/neutral: [review]." Zero-shot is the DEFAULT — always try it first. If results are inconsistent or wrong, escalate to few-shot. Most simple tasks work perfectly with zero-shot.
Provide 3–5 examples of input → desired output BEFORE the actual task. The model learns the PATTERN from examples. Critical for: custom categories, specific output formats, domain-specific terminology. "Classify tickets. Examples: 'Payment failed' → billing. 'App crashes' → technical. 'How to export?' → feature. Now classify: 'Charged twice' → ?" The model infers the classification pattern from your examples.
"Think step by step" — forces the model to show reasoning BEFORE the answer. Dramatically improves math, logic, and multi-step problems. Without CoT: "17 × 24?" → often wrong. With CoT: "17 × 24? Think step by step." → "17×20=340, 17×4=68, 340+68=408" → correct. Use for: analysis, debugging, calculations, comparisons, decision-making. Five words that transform AI accuracy.
"You are a [specific expert with specific experience]." Changes vocabulary, depth, and perspective. "You are a tax accountant specialising in Indian startups under ₹10Cr revenue" gives VERY different advice from "You are a financial advisor." The more specific the role, the more targeted the output. Stack context: "...with 10 years at a fintech company, familiar with RBI guidelines."
System prompt: persistent instructions framing ALL responses. User prompt: the specific request. System prompts define: persona, output format, constraints, knowledge boundaries. Example: "You are a customer support agent for Acme Corp. Only answer Acme product questions. If asked about competitors, say 'I can only help with Acme.' Always include a ticket number." System prompts = the personality and rules the AI follows.
Force specific formats: "Respond in JSON with keys: summary, sentiment, confidence." "Create a markdown table: Feature, Pros, Cons." "Write exactly 3 bullets, each under 20 words." "Respond ONLY with the answer, no explanation." Format control turns unpredictable AI into structured, parseable data. Essential for automation — without format control, AI output is useful to humans but useless to programs.
Complex tasks ≠ one giant prompt. Break into steps: (1) "Summarise this document" → (2) "Extract key risks from this summary" → (3) "Suggest mitigation for each risk" → (4) "Format as a table." Each step's output feeds the next. Chaining = multi-step reasoning without overloading a single prompt. Works better than one prompt trying to do everything at once.
Tell the model what NOT to do: "Do NOT include disclaimers." "Do NOT use bullet points — write in paragraphs." "Do NOT mention competitors." "If unsure, say 'I don't have enough information' instead of guessing." Negative constraints prevent common AI failure modes: unnecessary caveats, wrong format, hallucinated facts. What you EXCLUDE is as important as what you INCLUDE.
Build reusable templates: [CODE_REVIEW], [MEETING_NOTES], [EMAIL_DRAFT]. Variables: "You are a {role}. Industry: {industry}. Language: {language}." Templates save time and ensure consistency across a team. Individual prompt engineering doesn't scale — shared template libraries do. Organisations should maintain team-wide prompt repositories like they maintain code libraries.
AI-assisted code generation, debugging, refactoring, reviews, and testing
"Write a Python function that reads a CSV, removes rows with missing emails, and returns the cleaned DataFrame." The more specific: language, libraries, types, edge cases, error handling — the better the code. Always specify: "Include type hints", "Add docstrings", "Handle file-not-found." AI generates a working first draft in seconds — review, test, and refine.
Paste error + code → "Why does this error occur and how do I fix it?" Paste code + unexpected output → "This should return X but returns Y. What's wrong?" For complex bugs: "Explain line by line, then identify where the logic fails." LLMs are EXCELLENT at debugging — often better than searching online because they see your FULL context, not generic examples.
"Refactor to: follow PEP 8, reduce complexity, extract helpers, add error handling." "Convert class-based React component to functional with hooks." "This SQL is slow — optimise it." "Replace nested if-else with strategy pattern." Specify WHAT to improve — "make it better" is vague; "reduce cyclomatic complexity and extract reusable functions" is actionable.
"Review for: bugs, security vulnerabilities, performance, readability, SOLID principles. For each issue, explain WHY and suggest a fix." AI catches: SQL injection, unhandled exceptions, N+1 queries, missing validation, hardcoded secrets. Not a replacement for human review — an excellent first pass catching 70%+ of common issues before a human reviewer sees the code.
"Generate pytest tests: happy path, edge cases (empty, None, large input), error cases. Use parametrize." "Convert this manual test to Cypress." AI generates tests humans forget — especially edge cases and negative tests. Always review: AI may generate tests that pass but don't actually test meaningful behaviour.
"Generate README.md with: description, install, usage, API docs, contributing." "Add JSDoc to all functions." "Generate OpenAPI spec from this Express router." Documentation — the task developers hate most — becomes painless. Always review for accuracy: AI documentation reads well but may describe what the code SHOULD do, not what it ACTUALLY does.
GitHub Copilot: inline suggestions in VS Code/JetBrains. Cursor: AI-native editor with chat and multi-file editing. Sourcegraph Cody: enterprise with codebase context. Tab-completion (Copilot) vs chat-based editing (Cursor) — different workflows. Copilot for line-by-line, Cursor for multi-file refactoring, chat for architecture decisions.
Don't blindly copy AI code without understanding it. Don't use for security-critical code without expert review. AI generates plausible code that doesn't compile or has subtle logic errors — always TEST. Don't paste proprietary code into public AI tools. AI code tends to be verbose — refactor after generation. "AI-generated code is a DRAFT, not a deliverable." The programmer who understands the code is still essential.
Test case generation, edge cases, automation scripts, and test reports
Paste a user story → "Generate test cases covering: positive, negative, boundary, edge. Format: Test ID, Description, Preconditions, Steps, Expected Result, Priority." AI generates 30–50 test cases from a single requirement in minutes — hours of QA work compressed. Always review for domain-specific edge cases AI may miss.
"What edge cases should I test for a login form?" → AI generates 15+ cases: empty fields, SQL injection, XSS payloads, Unicode, extremely long inputs, special characters, case sensitivity, concurrent logins, session expiry, brute force. AI is EXCELLENT at brainstorming edge cases because it's seen millions of test scenarios in its training data.
"Generate 50 realistic Indian customer records: name, email, phone (Indian format), PAN (valid format), city, age (18–70). Include: missing fields, invalid formats, duplicate emails. Output as CSV." AI generates synthetic data faster than manual creation. Always validate: ensure no accidental real PII in generated data.
"Write a Playwright test: open login page, enter credentials, click submit, verify redirect, check dashboard shows username." AI provides 80% of the structure — selectors, waits, and assertions need customisation. Saves hours of boilerplate. Also: "Convert this manual test case to Cypress/Selenium."
Paste vague bug → "Rewrite with: title, environment, steps to reproduce, expected, actual, severity, suggested fix." AI transforms "login doesn't work" into a professional report with reproduction steps. Also: "What might cause this bug based on the symptoms?"
"Analyse results: total tests, pass/fail, failing categories, risk assessment, recommendations." "Given these tests and features, identify insufficient coverage areas." AI as QA analyst — summarising results and identifying gaps manual analysis might miss.
Requirements, user stories, meeting notes, process docs, and stakeholder communication
Paste client email or transcript → "Extract functional requirements (FR-001), non-functional requirements (NFR-001), constraints, assumptions, and out-of-scope items. Format as structured document." AI turns unstructured conversations into structured requirements. Always validate with stakeholders — AI may infer requirements not actually stated.
"From these requirements, generate user stories: As a [user], I want [goal], so that [benefit]. Include acceptance criteria (Given/When/Then). Prioritise with MoSCoW." AI generates 20–30 stories from a requirements doc in minutes. Review for: correct user type, testable acceptance criteria, appropriate granularity (not too big, not too small).
Paste transcript → "Extract: decisions made, action items (owner + deadline), open questions, risks, next steps. Format as structured summary." AI transforms 60 minutes of discussion into 1-page actionable summary. Use with: Otter.ai, Teams/Zoom transcripts, or manual notes. The single biggest productivity multiplier for BAs.
"Document this business process step-by-step: trigger, steps, decision points, parallel activities, end states." "Generate Mermaid diagram syntax for this workflow." AI generates process docs convertible to visual flowcharts. Mermaid syntax pastes directly into Notion, GitHub, or any Mermaid renderer for instant diagrams.
"Draft email to engineering explaining the 2-week delay. Tone: professional, empathetic. Include: reason, impact, mitigation, ask for input." "Write executive status update: 5 sentences, focus on progress, risks, next milestone." AI adapts tone to audience — technical for engineers, concise for executives, detailed for PMs.
"Analyse 3 competitors: features, pricing, audience, strengths, weaknesses, positioning. Format as comparison table + strategic recommendation." AI as research assistant — faster than manual research. Always verify claims and check that competitor data is current (AI may have outdated information).
Bias, privacy, hallucinations, IP, and building organisational AI policies
LLMs inherit biases from training data: gender stereotypes ("nurse" → female, "engineer" → male), racial biases (different treatment by name ethnicity), cultural biases (Western-centric perspectives). Detection: test prompts with different demographic variables, compare outputs. Mitigation: diverse testing, explicit anti-bias instructions, human review for high-stakes decisions. "AI is not neutral — it reflects its training data."
Five strategies: (1) ask for sources, then VERIFY they exist, (2) use RAG to ground responses in real data, (3) set temperature to 0 for factual tasks, (4) instruct "If unsure, say 'I don't know' instead of guessing", (5) cross-check with a second model or human expert. For legal, medical, and financial content: NEVER use AI output without human verification. Hallucinations are a fundamental property, not a bug to be fixed.
What you paste into free-tier AI may be used for training. Never paste: proprietary code, customer PII, financial data, legal documents, trade secrets. Enterprise alternatives: Azure OpenAI (data stays in your tenant), API with zero retention, self-hosted open-source models. Know your organisation's AI policy BEFORE using any tool. India's DPDP Act 2023 has implications for AI data processing.
AI-generated content may inadvertently reproduce copyrighted training material. Who owns AI-generated code/text? Legally unsettled globally. Best practices: treat output as first draft needing human modification, don't claim as entirely original, be cautious in open-source (licensing ambiguity). India's position on AI-generated IP is evolving — stay informed.
AI should ASSIST (not DECIDE) for: medical diagnoses, legal judgments, hiring, financial advice, safety-critical systems. AI can handle: drafting emails, code suggestions, document summaries, test cases. The spectrum: human decides → AI suggests + human decides → AI decides + human reviews → full autonomy. Most workplace AI in 2025 should be in "AI suggests + human decides." Moving to autonomy requires guardrails and governance.
Every organisation needs a policy covering: approved tools (enterprise ChatGPT yes, free tier no), prohibited data (no customer PII), review requirements (human review for client deliverables), disclosure (when to tell clients AI was used), training (mandatory AI literacy). Without a policy, employees use AI anyway — with risk. With a policy, they use it safely and effectively. Draft a sample policy as an exercise.
Same prompt → GPT-4, Claude, Gemini. Document: which model gave the best answer? Which hallucinated? Which followed format instructions? Build a personal model selection guide.
One task, four techniques: zero-shot → few-shot → CoT → role-based. Score each output on accuracy, completeness, and format. Which technique wins for which task type?
PBuggy code → debug → refactor → generate tests → generate docs. All with AI. Time: 30 minutes. Compare with doing it manually. Measure: time saved, issues caught, quality of output.
Client brief → requirements → user stories → meeting summary → stakeholder email. All AI-assisted. Compare AI output quality with manually written BA documents.
Feature spec → generate 30 test cases → identify edge cases → write automation script → test report. Count how many edge cases AI found that you missed.
Test bias with demographic variations. Find 3 hallucinations. Draft an AI usage policy. Evaluate: can this AI output be used without human review? Why or why not?
Trainers demonstrate techniques on live AI tools — students follow along on their own devices. Every prompt technique is shown, then practised immediately. Not slides about AI — live AI.
Weekly challenges: "Get AI to generate a perfect test plan for this feature" "Debug this code using only AI." Leaderboard for best prompts (quality + speed).
Developers practise code generation. QA practises test cases. BAs practise requirements extraction. Everyone learns the shared foundations, then applies to their specific role.
Students build a personal library of 20+ reusable prompt templates. The toolkit they'll carry into every job — ready to be productive with AI from day one at any company.
"Experience with AI tools" or "Proficiency in AI-assisted workflows" appears in 60%+ of 2025–26 tech job postings — developer, tester, analyst, and non-tech roles alike. Students who can demonstrate AI fluency are preferred over those who can't. This module builds the demonstrable skill, not just the buzzword.
A developer who can debug with AI, a QA who can generate test cases with AI, a BA who can extract requirements with AI — each is 3–10x more productive than one who works without AI. Companies hire for PRODUCTIVITY. AI-fluent employees deliver in hours what traditionally took days. This module builds that speed advantage.
The employee who blindly trusts AI output causes data breaches (pasting PII), legal issues (hallucinated citations), and quality failures (untested AI code). The employee who understands hallucinations, bias, and privacy uses AI SAFELY. Module 6 (Ethics) is what prevents AI from becoming a liability.
This module requires ZERO coding. Commerce students use AI for business analysis. Mechanical students use AI for report writing. CS students use AI for coding and testing. AI fluency is NOT a CS-only skill — it's the universal productivity multiplier for every branch and every role.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
