AI Growth Path: Foundation

E-Learning Course for Xebia IT Professionals

Course Overview

Welcome to AI Growth Path: Foundation — your first step towards becoming an AI-empowered IT professional at Xebia.

At the Foundation level, you'll begin treating Generative AI as a real work tool, not just an internet curiosity. You'll discover how AI can help you with code, tests, analysis, and documentation — while learning to approach it thoughtfully and critically.

This course is built on Xebia’s Core Principles for Working with AI. Before and during the course, you are expected to familiarize yourself with these principles and apply them consistently. They define how we use AI at Xebia: safely, responsibly, and with humans always in control. Understanding and following these principles is not optional — it is a fundamental requirement for using AI in our projects and with our clients.

By the end of this course, you will:

• Understand what language models are and their limitations
• Know what information you can share with AI and what you must protect
• Write simple, clear prompts that get results
• Critically evaluate AI outputs
• Understand context and tokens in practical terms

Estimated completion time: 1 hour

Module 1: Introduction

Why GenAI Matters for IT Teams

Generative AI is rapidly becoming a fundamental work tool in modern IT teams. Whether you're a developer writing code, a QA engineer creating test cases, a business analyst documenting requirements, or a project manager organizing workflows — AI can accelerate your work significantly.

But here's the key insight: AI is your assistant and accelerator, not your replacement. You remain the expert and final authority.

The AI Growth Path at Xebia

The AI Growth Path consists of three levels:

This course covers the Foundation level — building the foundation you need for everything that follows.

What You'll Learn

By completing this course, you'll develop these core competencies:

1. Basic Understanding of GenAI and LLMs — Know what language models are and why they can make mistakes
2. Simple Prompting — Formulate clear, structured prompts for common tasks
3. Critical Evaluation — Assess whether AI outputs make sense and require verification
4. Context Fundamentals — Understand how context affects model responses

How to Use This Course

Each module includes:

• Core content — Essential concepts and principles
• Practical examples — Real prompts you can adapt
• Quick checks — Knowledge verification points
• Tips — Shortcuts and best practices

Take your time. The goal isn't speed — it's building solid foundations for your AI journey.

Module 2: What is GenAI and How Does It Work?

What is GenAI

Generative AI (GenAI) is a type of artificial intelligence that can create new content — including text, images, code, audio, and video — based on patterns learned from training data. Unlike traditional AI systems that classify or analyze existing data, generative AI produces original outputs that didn't exist before.

GenAI is built on foundation models — large-scale models trained on massive datasets that can be adapted to a wide range of tasks. The most well-known examples are Large Language Models (LLMs) like GPT, Claude, and Gemini, which specialize in understanding and generating human language.

Understanding Language Models

A Large Language Model (LLM) is essentially a prediction engine. It's trained on vast amounts of text data and learns to predict what word (or token) should come next in a sequence.

When you send a prompt to an AI assistant, here's what happens:

1. Your text is converted into tokens (pieces of words)
2. The model predicts the most likely next token
3. That token is added to the sequence
4. The process repeats until the response is complete

Key insight: The model doesn't "know" things in the way humans do. It generates text based on patterns learned during training.

Generation vs. Search

It's crucial to understand the difference:

When you ask AI "What is the capital of France?", it doesn't look this up — it generates "Paris" because that's the statistically likely response based on its training.

Why AI Makes Mistakes: Understanding Hallucinations

Hallucinations are instances where AI generates content that sounds plausible but is factually incorrect, made up, or inconsistent.

Common types of hallucinations include:

• Fabricated facts — The AI invents statistics, quotes, or events
• False citations — References to papers, books, or sources that don't exist
• Confident errors — Incorrect answers delivered with complete confidence
• Plausible nonsense — Responses that sound reasonable but are wrong

Why do hallucinations happen?

AI models are probabilistic — they generate the most likely next word based on patterns. They don't have a concept of "truth" or "facts." When the training data is insufficient or the question is ambiguous, the model still produces an answer — it just might be wrong.

💡 Remember: GenAI is probabilistic and prone to hallucinations — verify citations actually exist, check facts against reliable sources, and never trust outputs blindly.

The Knowledge Cutoff

Every AI model has a knowledge cutoff date — the point when its training data ends. The model doesn't know about events that happened after this date unless it has access to web search capabilities.

Practical implications:

• Always verify time-sensitive information
• Be cautious with questions about recent events
• Use web-enabled AI tools when current information is needed

⚠️ Important: LLMs don't inherently know the current date. When you ask for information "from last week" or "recent news," a standalone LLM cannot interpret these relative time references correctly. There are two ways to handle this: (1) provide explicit dates in your prompts, for example, instead of "What happened last week?", say "What happened between November 25-29, 2024?", or (2) include the current date in your prompt, such as "Today is December 5, 2024. Summarize news from the past week." Note that this limitation applies only to standalone LLMs — modern AI Assistants (like ChatGPT, Claude, or Gemini) automatically have access to the current date through their system configuration, so you typically don't need to provide this information yourself.

Quick Check ✔

Before moving on, make sure you understand:

• [ ] LLMs are prediction engines, not knowledge databases
• [ ] Generation is different from retrieval
• [ ] Hallucinations are a fundamental limitation of current AI
• [ ] AI can be confidently wrong

Module 3: Security and AI Usage Guidelines

Why Security Matters

When you use AI tools, you're sending data to external systems. Understanding what you can and cannot share is essential for protecting Xebia, our clients, and yourself.

⚠️ Core Principle: Protect Sensitive Information. Exercise caution with your context. Never share confidential data, personal information, proprietary code, or anything that could create security or privacy risks.

General Data Protection Principles

The principles outlined in this section represent general baseline rules for working with AI tools. These are the default guidelines you should follow in most circumstances. However, it's important to understand that exceptions can be applied under specific conditions (see "When Exceptions Apply" below).

What You Should Generally NOT Share with AI

PII - Personally Identifiable Information
GDPR - General Data Protection Regulation - reference

When Exceptions Apply

While the general principles above should be your default approach, there are specific circumstances where working with proprietary code or confidential data in AI tools may be permitted:

Exception 1: Client Consent for Coding Tools

When you have explicit client consent to use AI coding tools with their code, you may work with proprietary code in approved AI assistants. This requires:

• Written or documented approval from the client
• Clear understanding of which tools are permitted
• Adherence to any specific restrictions the client has set
• Compliance with the project's data handling agreements

Example: A client explicitly approves the use of GitHub Copilot or Claude for code assistance on their project. In this case, you may use these tools with the client's codebase according to the agreed terms.

Exception 2: Organization-Approved Tools for Confidential Data

When using licensed tools or services that have been specifically approved by your organization for working with confidential data (including personal data), you may process such data within these tools. This applies when:

• The tool has been vetted and approved by Xebia's security/compliance team
• Appropriate data processing agreements (DPAs) are in place
• The tool has enterprise-grade privacy controls enabled
• Usage aligns with GDPR and other applicable regulations

Example: Your organization has approved an enterprise version of an AI tool with a Data Processing Agreement that allows processing of certain categories of personal data. In this case, you may use this tool according to the approved use cases and data categories.

Important Notes on Exceptions

• Always verify that you have the appropriate consent or approval before applying any exception
• When in doubt, ask your project lead, security team, or compliance officer
• Exceptions do not override security best practices like never sharing credentials or API keys
• Even with exceptions, apply the principle of minimal data sharing — only share what's necessary

Safe Usage Guidelines

Before every AI interaction, ask yourself:

1. Does this contain any sensitive information?
2. Would I be comfortable if this appeared in a public forum?
3. Does this comply with my project's and client's policies?
4. Do I have explicit consent or approval to share this type of data?

💡 Principle: Use Approved Tools Only. Work exclusively with verified and approved GenAI tools. Avoid unapproved or unknown AI services that may lack proper security controls or data handling practices.

Data Handling Best Practices

Control Data Usage: Ensure your inputs aren't collected for training or other purposes. Understand your platform's data policies and use privacy-preserving options when available.

Practical steps:

• Anonymize data — Replace real names, emails, and identifiers with placeholders
• Use synthetic examples — Create realistic but fake data to feed to AI tools
• Strip context — Remove project/client identifiers when possible
• Check tool settings — Some AI tools have "private" or "no training" modes - set these options if available

Your Security Checklist

Use this checklist before every AI session:

Before Using AI - Quick Security Check
══════════════════════════════════════

☐ No passwords, API keys, or credentials
☐ No personal data (names, emails, phone numbers)
☐ No client-identifiable information
☐ No proprietary source code
☐ No financial or strategic information
☐ Using an approved AI tool
☐ Following project-specific AI guidelines

If sharing proprietary code or confidential data:
☐ I have documented client consent OR
☐ I am using an organization-approved tool for this data type
☐ I understand and comply with the specific terms of the exception

When in Doubt

If you're unsure whether something can be shared:

1. Don't share it — When in doubt, leave it out
2. Ask your lead — Get guidance for edge cases
3. Anonymize first — Remove identifying information
4. Check policies — Review project-specific guidelines
5. Verify exceptions — Confirm you have appropriate consent or approval

💡 Remember: Always align with your project's, client's, and company's GenAI usage rules. Stay within approved use cases and compliance requirements.

Module 4: Introduction to AI Assistants

What Are AI Assistants?

AI assistants are interfaces that allow you to interact with language models through conversation. They're built on foundation models and designed to understand your requests and generate helpful responses.

Modern AI assistants can:

• Answer questions and explain concepts
• Generate and review code
• Create documentation and content
• Analyze and summarize information
• Help with problem-solving and brainstorming

How AI Assistants Are Built

Modern AI assistants like ChatGPT, Claude, or Gemini may seem like magic, but they follow a clear architectural pattern. Understanding these building blocks helps you work with AI tools more effectively and set realistic expectations for what they can do.

💡 AI Assistant ≠ LLM: A large language model is just one component of an AI assistant. The complete assistant also includes the user interface, context (system prompt, conversation history, current prompt, attachments), and external tools. The LLM provides the core reasoning capabilities, but it's the combination of all these components that creates the full assistant experience.

An AI assistant consists of several layers:

┌─────────────────────────────────┐
│      User Interface (Chat)      │
├─────────────────────────────────┤
│   Large Language Model (LLM)    │
├─────────────────────────────────┤
│            Context              │
│  ┌───────────────────────────┐  │
│  │ • System Prompt           │  │
│  │ • Conversation History    │  │
│  │ • Current User Prompt     │  │
│  │ • Attachments / Files     │  │
│  │ • Tool Results            │  │
│  └───────────────────────────┘  │
├─────────────────────────────────┤
│        External Tools           │
│   (Search, Code, APIs, etc.)    │
└─────────────────────────────────┘

Runtime components:

• User Interface — Where users type prompts and read responses (web chat, mobile app, API, etc.)
• LLM — The underlying model that processes all inputs and generates responses
• Context — All information provided to the model for generating a response:
  • System Prompt — Instructions that define the assistant's behavior, persona, tone, and constraints
  • Conversation History — The prior exchange of messages in the current session
  • Current User Prompt — The user's latest message or query that triggers the response
  • Attachments — Files, images, or documents shared by the user
  • Tool Results — Data returned from external tool calls
• External Tools — Capabilities the model can invoke: web search, code execution, database queries, third-party APIs, or custom functions

How the model (LLM) itself is created:

Before deployment, the LLM is pre-trained on large and diverse text corpora (books, websites, academic papers, code, etc.). This training process is what gives the model its language understanding, factual knowledge, and reasoning abilities.

At runtime, context and tools shape how the model applies its capabilities to each specific interaction.

Popular AI Assistants

Here are some widely-used general-purpose AI assistants:

ChatGPT (OpenAI)

• General-purpose AI assistant for a wide range of tasks
• Multimodal: processes text, images, and audio; generates text, images, and speech
• Strong coding capabilities with code execution and agentic features
• Versatile for writing, analysis, and creative tasks
• Available at: chatgpt.com

Claude (Anthropic)

• General-purpose AI assistant for a wide range of tasks
• Multimodal: processes text and images; generates text
• State-of-the-art (SOTA) coding performance with dedicated developer tools
• Excels at reasoning, analysis, and handling long documents
• Available at: claude.ai

Gemini (Google)

• General-purpose AI assistant for a wide range of tasks
• Natively multimodal: processes and generates text, images, audio, and video
• Strong coding and reasoning capabilities
• Deep integration with Google Workspace and Search
• Available at: gemini.google.com

Getting Started with AI Assistants

Step 1: Choose Your Tool Start with an approved tool within your organization. Each has strengths depending on your task.

Step 2: Understand the Interface Most assistants work similarly:

• A text input for your prompts
• A conversation history
• Options for new conversations
• Sometimes file upload capabilities

Step 3: Start Simple Begin with straightforward questions and gradually explore more complex interactions.

Step 4: Iterate If the first response isn't quite right, refine your request. AI conversations are iterative.

Model Parameters (Awareness)

When using AI through APIs or advanced interfaces, you may encounter these settings:

LLMs always generate responses based on probabilities learned during training. Adjusting parameters like temperature changes how the model samples possible outputs, but it does not guarantee factual correctness.

Module 5: Fundamentals of Prompt Engineering

What is Prompt Engineering?

Prompt engineering is the art and science of crafting inputs that guide AI models toward generating useful outputs. The quality of your prompt directly influences the quality of the response.

💡 Principle: Communicate with Precision. Be detailed, specific, and clear in your prompts. Thoroughly explain your expectations, provide examples when possible, and guide the AI toward the outputs you need. Quality inputs drive quality outputs.

The Anatomy of an Effective Prompt

A well-structured prompt typically includes:

┌─────────────────────────────────────────┐
│  1. ROLE (optional)                     │
│     Who should the AI act as?           │
├─────────────────────────────────────────┤
│  2. TASK                                │
│     What do you need done?              │
├─────────────────────────────────────────┤
│  3. CONTEXT                             │
│     Background information needed       │
├─────────────────────────────────────────┤
│  4. FORMAT                              │
│     How should the output look?         │
├─────────────────────────────────────────┤
│  5. CONSTRAINTS (optional)              │
│     Any limitations or requirements     │
└─────────────────────────────────────────┘

The Four Pillars of Good Prompts

1. Be Clear About Your Goal

Weak prompt:

Tell me about testing.

Strong prompt:

Explain the difference between unit tests and integration tests
for a backend developer new to test-driven development.

2. Provide Necessary Context

Weak prompt:

Fix this bug.

Strong prompt:

I have a Python function that calculates shipping costs.
It returns incorrect values when the weight is exactly 10kg.
Here's the function:

[code snippet]

The expected result for 10kg is $15, but it returns $20.
What's causing this bug?

3. Specify the Desired Format

Specifying output format is crucial, especially when working with code, configurations, and structured data. Clear format instructions help ensure you get usable, consistent outputs.

Weak prompt:

Give me some API endpoints for a user management system.

Strong prompt:

List 5 REST API endpoints for a user management system.
For each endpoint, provide:
- HTTP method
- URL path
- Brief description
- Example request body (if applicable)

Return the response as a JSON array.

4. Set the Expertise Level

💡 Principle: Set the Appropriate Expertise Level. Specify whether you need expert-level, professional, or beginner-friendly responses.

For beginners:

Explain Docker containers to someone who has never used them,
using simple analogies.

For experts:

Explain the networking differences between Docker bridge
and host modes, focusing on performance implications
for high-throughput applications.

Prompting Techniques for Starters

Zero-Shot Prompting

The simplest approach — you give a task without any examples. The model relies entirely on its training.

Example:

Classify this customer review as positive, negative, or neutral:
"The product arrived on time but the packaging was damaged."

One-Shot and Few-Shot Prompting

You provide one or more examples to show the model what you expect.

Example (Few-Shot):

Classify these reviews:

Review: "Absolutely love it! Best purchase ever!"
Classification: Positive

Review: "Complete waste of money. Broke after one day."
Classification: Negative

Review: "The product arrived on time but the packaging was damaged."
Classification:

Few-shot prompting is especially useful when you want a specific output format or style.

💡 Best Practice: Use at least 3-5 examples for few-shot prompting. Include diverse examples that cover edge cases.

Specifying Output Formats: A Critical Skill

When working with AI, especially for code and configuration tasks, specifying the exact output format is essential. This section covers the most important structured formats and how to request them effectively.

Why Format Matters

Without clear format instructions, AI may return:

• Inconsistent structures across responses
• Prose mixed with code
• Formats that are difficult to parse or use programmatically
• Extra explanations when you just need the data

Example prompt for JSON output:

Analyze the following code review and provide your assessment.

Return your response as valid JSON with this exact structure:
{
  "summary": "Brief overall assessment",
  "issues": [
    {
      "severity": "high|medium|low",
      "line": <line_number>,
      "description": "What the issue is",
      "suggestion": "How to fix it"
    }
  ],
  "score": <1-10>
}

Return ONLY the JSON object, no additional text or markdown formatting.

Tips for reliable JSON output:

• Show the exact structure you expect
• Specify data types (string, number, array, etc.)
• Use "Return ONLY the JSON" to avoid extra text
• Ask for "valid JSON" to ensure proper syntax
• If needed, specify "no markdown code blocks"

YAML Format

YAML (YAML Ain't Markup Language) is ideal for:

• Configuration files (Kubernetes, Docker Compose, CI/CD pipelines)
• Human-readable structured data
• Infrastructure as Code definitions
• Settings and environment configurations

Example prompt for YAML output:

Create a Docker Compose configuration for a web application with:
- A Node.js backend service
- A PostgreSQL database
- A Redis cache

Return the response as valid YAML for docker-compose.yml.
Include appropriate environment variables and volume mounts.
Return ONLY the YAML content, no explanations.

Tips for reliable YAML output:

• Specify the target file/tool (e.g., "for docker-compose.yml", "for Kubernetes deployment")
• YAML is more readable but whitespace-sensitive — ask the AI to be careful with indentation
• For complex configurations, provide a partial example of the structure you expect

Using Placeholders in Structured Outputs

When you need the AI to generate a structured response but want to clearly indicate where specific content should go, use placeholders. This technique is especially useful for:

• Creating templates
• Defining response schemas
• Ensuring consistent output structure

Example with placeholders:

Analyze this customer support ticket and respond in this exact JSON format:

{
  "ticket_category": "<category>",
  "priority": "<high|medium|low>",
  "sentiment": "<positive|neutral|negative>",
  "summary": "<brief_summary>",
  "suggested_response": "<suggested_response>",
  "escalation_needed": <true|false>
}

Replace the placeholders with actual values based on the ticket content.
Return ONLY the JSON object.

Another example with detailed placeholders:

Generate a code review response using this structure:

{
  "initial_comments": "<initial_comments>",
  "response": "<response>"
}

Where:
- <initial_comments> = Your first impressions and overall assessment
- <response> = Detailed feedback with specific suggestions

Return valid JSON only.

Ensuring Format Compliance

To maximize the chances of getting the exact format you need:

1. Be explicit: State the format clearly ("Return as JSON", "Output as YAML")

2. Show the structure: Provide a template or example of what you expect

3. Eliminate extras: Add "Return ONLY the [format], no additional text or explanations"

4. Specify edge cases: What should happen with null values? Empty arrays?

5. Request validation: "Ensure the output is valid [JSON/YAML] that can be parsed"

Example of a highly constrained format request:

Convert the following list of users to JSON.

Requirements:
- Return ONLY valid JSON, no markdown code blocks
- Use snake_case for all keys
- Dates should be in ISO 8601 format (YYYY-MM-DD)
- Empty fields should be null, not empty strings
- The root element should be an object with a "users" array

Example structure:
{
  "users": [
    {
      "user_id": 1,
      "full_name": "John Doe",
      "email": "john@example.com",
      "created_at": "2024-01-15"
    }
  ]
}

LLM output modelling: readability and complexity

Readability modeling means telling AI how simple or complex its answer should be. It's different from structured output, which controls format (JSON, lists, tables). Readability modeling controls how much effort it takes to read and understand the answer. Great for communicating with different audiences or exploring unfamiliar topics step by step.

Why Use Readability Modeling?

• Audience matching — Automatically adjust technical depth based on who will read the output (junior dev vs. CTO vs. end user)
• Documentation quality — Generate user guides, READMEs, and wikis that are actually readable by their intended audience
• Stakeholder communication — Translate technical incidents, architecture decisions, or project updates into business-friendly language
• Onboarding materials — Create learning content that doesn't overwhelm newcomers with jargon
• Accessibility — Make content understandable for non-native speakers or people with different technical backgrounds
• Consistency — Maintain uniform complexity across large documentation sets
• Time savings — Skip the manual rewriting step when adapting content for different audiences
• Progressive learning — Explore unfamiliar topics by starting simple and gradually increasing complexity. Ask for Flesch 90 first to grasp the basics, then request 60, 40, and 20 to progressively deepen your understanding with more technical details and nuance. Great for ramping up on new technologies or domains.

Techniques:

• ELI5 (Explain Like I'm 5) — request to explain a topic as if for a complete beginner, using simple words and everyday analogies. Great for translating technical concepts for non-technical stakeholders, writing onboarding materials, or creating introductory documentation. The AI will avoid jargon and use comparisons to familiar, everyday objects and situations. Example prompt: ELI5: What is Kubernetes?
• Gunning Fog Index — indicator showing how many years of education are needed to understand a text (6 = elementary school, 12 = college student, 17+ = expert). Useful when you need precise control over complexity level and want to maintain consistent standards across documentation. You can set specific targets for different audiences — e.g. Fog 10 for user guides, Fog 14 for developer docs. Example prompt: Explain our CI/CD pipeline. Target Fog Index 10 for new interns.
• Flesch Reading Ease — scale 0-100 measuring reading ease. Higher score means simpler text (90+ = very easy, 60-70 = standard, below 30 = difficult). Works inversely to Fog Index — you ask for higher numbers when you want easier text. Best for user-facing content like help articles, emails, or public documentation where accessibility matters. Example prompt: Explain what's transformer architecture. Flesch reading ease 70+.
• SMOG (Simple Measure of Gobbledygook) — indicator focused specifically on eliminating long, polysyllabic words and jargon. Expressed as grade level (8 = middle school, 12 = high school, 16+ = university). Particularly effective for rewriting error messages, incident reports, or any content where technical terminology creates unnecessary barriers. Example prompt: Rewrite this error message with SMOG grade 8. Original: 'Authentication failed due to invalid credentials. OAuth token expired.'

Universal Prompt Templates

Template 1: The Task Template

I need to [TASK].

Context:
- [Relevant background information]
- [Current situation]
- [Any constraints]

Please provide [SPECIFIC OUTPUT FORMAT].

Template 2: The Role Template

Act as a [ROLE/PERSONA].

I need help with [TASK].

Here's the situation:
[CONTEXT]

Please [SPECIFIC REQUEST] in [FORMAT].

💡 Principle: Use Personas to shape the AI's Approach. Define the role the AI should take when generating your answer.

Example Personas for IT Professionals:

Template 3: The Analysis Template

Analyze the following [ITEM TYPE]:

[ITEM TO ANALYZE]

Focus on:
1. [Aspect 1]
2. [Aspect 2]
3. [Aspect 3]

Provide your analysis in [FORMAT].

Practical Examples by Output Type

Asking for Code

Write a Python function that:
- Takes a list of integers as input
- Returns the sum of all even numbers
- Handles empty lists gracefully
- Includes docstring and type hints

Asking for Explanations

Explain how JWT (JSON Web Tokens) work for authentication.

Structure your explanation as:
1. What problem JWTs solve
2. How they're structured
3. The authentication flow
4. Common security considerations

Target audience: Backend developers new to authentication.

Asking for Documentation

Write API documentation for this endpoint:

POST /api/users
Creates a new user account.

Required fields: email, password, name
Optional fields: phone, role

Include:
- Description
- Request/response examples
- Error codes
- Authentication requirements

Asking for Structured Data (JSON)

List 5 REST API endpoints for a user management system.

For each endpoint, provide the HTTP method, URL path,
brief description, and example request body (if applicable).

Return the response as a JSON array with this structure:
[
  {
    "method": "GET|POST|PUT|DELETE",
    "path": "/api/...",
    "description": "What this endpoint does",
    "request_body": null or { ... }
  }
]

Return ONLY the JSON array.

Asking for Configuration (YAML)

Create a GitHub Actions workflow that:
- Triggers on push to main branch
- Runs tests using Node.js 18
- Builds the application
- Deploys to staging environment

Return as valid YAML for .github/workflows/deploy.yml.

Common Prompting Mistakes

Quick Prompt Checklist

Before sending your prompt, verify:

Prompt Quality Check
════════════════════════

☐ Clear task/question defined
☐ Relevant context provided
☐ Output format specified
☐ Expertise level appropriate
☐ No sensitive information included
☐ Single focused request

Module 6: Critical Thinking About AI Outputs

Why Critical Evaluation Matters

AI can be confidently wrong. It delivers incorrect information with the same tone as correct information. Your ability to critically evaluate outputs is essential.

💡 Principle: Verify All AI Outputs. Critically review everything the AI generates. Remember that GenAI is probabilistic and prone to hallucinations — verify citations actually exist, check facts against reliable sources, and never trust outputs blindly.

Common AI Errors

1. Factual Errors

AI may state incorrect facts confidently:

• Wrong dates, numbers, or statistics
• Misattributed quotes
• Incorrect technical specifications
• Outdated information

Example:

AI: "Python 2.7 was released in 2020 with significant performance improvements."

Reality: Python 2.7 was released in 2010 and reached end-of-life in 2020.

2. Fabricated References

AI can create citations that don't exist:

• Academic papers with realistic-sounding titles
• Book references with plausible authors
• URLs that lead nowhere
• Fake statistics with made-up sources

Always verify: If the AI cites a source, check that it actually exists.

3. Logical Inconsistencies

Within the same response, AI might:

• Contradict itself
• Draw conclusions that don't follow from premises
• Mix up cause and effect
• Apply correct principles incorrectly

4. Code Errors

AI-generated code may:

• Have syntax errors
• Use deprecated APIs or methods
• Contain security vulnerabilities
• Work in examples but fail in edge cases
• Reference non-existent libraries or functions

💡 Principle: Review, Test, and Verify All Outputs. Critically examine every line of AI-generated code. Test thoroughly for functionality, security vulnerabilities, logic errors, and edge cases. Never commit code you don't understand.

The Sanity Check Framework

Use this quick framework to evaluate AI outputs:

S - Source Check

• Can I verify this information elsewhere?
• Does the AI cite sources? Do they exist?

A - Authority Check

• Is the AI qualified to answer this?
• Am I qualified to verify this answer?

N - Numbers Check

• Do the numbers make sense?
• Are statistics plausible?
• Are dates and figures correct?

E - Edge Case Check

• Does this work in unusual situations?
• What happens with invalid inputs?
• Are there exceptions not mentioned?

Practical Verification Strategies

For Code

1. Read and understand every line
2. Test with normal inputs
3. Test with edge cases (empty, null, extreme values)
4. Check for security issues
5. Verify library/API usage is current
6. Run linting and static analysis

For Facts and Claims

1. Cross-reference with authoritative sources
2. Check official documentation
3. Verify dates and numbers
4. Be skeptical of specific statistics
5. Look for primary sources

For Technical Explanations

1. Does it match your existing knowledge?
2. Are the concepts applied correctly?
3. Would an expert agree?
4. Test the explanation with simple examples

Red Flags to Watch For

Be extra cautious when AI output includes:

Building Verification Habits

For every AI output, ask:

1. Do I understand it? — Don't use code or explanations you don't comprehend
2. Does it make sense? — Trust your instincts when something feels off
3. Can I verify it? — Check at least the key claims
4. What could go wrong? — Consider failure modes

💡 Principle: Maintain Human Oversight and Control. Always keep a human in the loop for verification and decision-making.

When to Double-Check Everything

Always verify more carefully when:

• Output will be seen by clients or stakeholders
• Code will run in production
• Information will be published or shared
• Decisions have significant consequences
• You're working outside your expertise
• The topic is time-sensitive

Module 7: Context, Tokens, and Model Limitations

Understanding Context

Context is the information available to the AI when generating a response. This includes:

• Your current prompt
• Previous messages in the conversation
• Tool results
• Any files or documents you've attached
• The system instructions (invisible to you)

💡 Principle: Provide Rich Context. The AI doesn't know your situation or environment. Include relevant documentation, data files, code snippets, system outputs, or background information that builds the necessary context for accurate, tailored responses.

What Are Tokens?

Tokens are the units that language models use to process text. They're not exactly words — a token might be:

• A whole short word: "the" = 1 token
• Part of a longer word: "understanding" = 2-3 tokens
• Punctuation: "." = 1 token
• Special characters or spaces

Rough estimation: 1 token ≈ 4 characters or ¾ of a word in English.

Examples:

The Context Window

Every LLM has a context window — the maximum number of tokens it can process at once. This includes both your input and the AI's response.

Why this matters:

• Long conversations can exceed the limit
• Attached documents consume context space
• Very long prompts leave less room for responses
• When the limit is reached, older context is "forgotten"

Context Best Practices for Starters

Keep It Focused

Include only information relevant to your request. Unnecessary context wastes tokens and can confuse the model.

Too much context:

I'm working on an e-commerce project for a big pharmacy client. The deadline is this Friday and the QA team keeps finding bugs. We track everything in Jira (ticket #402). I wrote a calculateDiscount function that subtracts a percentage from the price. I need to write tests for it, but I'm running out of time.

Can you generate the tests?

Focused context:

I'm using Jest with TypeScript.
Write unit tests for the calculateDiscount(price: number, rate: number) function. Please cover edge cases, such as negative prices and 0% discount.

Structure Your Context

When you need to provide background information, structure it clearly:

Context:
- Framework: React 18 with TypeScript
- Styling: Tailwind CSS
- Issue: Component not rendering correctly on mobile

Question:
How do I make this responsive?

[code snippet]

Use Relevant Details

Some context is essential:

I'm debugging a Node.js Express API (version 4.18).
The endpoint returns 500 errors intermittently.
Here's the error log:

[relevant log entries]

Here's the handler code:

[code]

What might cause the intermittent failures?

Common Context Mistakes

Understanding Model Limitations

Knowledge Cutoff

Models don't know about events after their training date. For current information, use AI tools with web search capabilities.

LLMs and Date Awareness

⚠️ Important: LLMs have no inherent sense of time. They don't know what day, month, or year it is when you're asking your question. This creates practical issues when you use relative time references in your prompts.

The problem:

❌ "Show me news from last week"
❌ "What are the latest updates?"
❌ "Find recent articles about..."

A standalone LLM cannot interpret "last week" or "recent" because it doesn't know when "now" is.

The solutions:

1. Provide explicit dates:

✅ "Show me news from November 25-29, 2024"
✅ "What updates were announced after October 2024?"
✅ "Find articles about AI published in Q3 2024"

2. Include today's date in your prompt:

✅ "Today is December 5, 2024. Summarize the main tech news from the past week."
✅ "The current date is December 5, 2024. What recent developments have there been in cloud computing?"

Note for AI Assistant users:

This limitation applies only to standalone LLMs. Modern AI Assistants (ChatGPT, Claude, Gemini) automatically have access to the current date through their system configuration. You typically don't need to provide this information yourself when using these tools — they can correctly interpret relative time references like "last week" or "yesterday."

Reasoning Limits

Despite improvements, AI can struggle with:

• Complex multi-step logic
• Mathematical calculations (use calculators)
• Keeping track of many variables
• Long-term planning

No Memory Between Sessions

Each new conversation starts fresh. The AI doesn't remember previous chats unless you provide context.

Starter Principles for Context

At the Foundation level, focus on these principles:

1. Keep it short — Include only what's necessary
2. Keep it concrete — Specific details beat vague descriptions
3. Keep it focused — One topic or problem at a time
4. Keep it current — Provide the latest relevant information

💡 Principle: Ground AI in Reliable Sources. Anchor AI's knowledge in verified documentation, established facts, and authoritative sources. Don't let it operate purely from training data when you can provide specific, current information.

What is Grounding?

Grounding is the process of connecting an AI model's output to verifiable sources of information — essentially giving the AI a "reality check."

Without grounding, AI models rely solely on their training data, which may be outdated or lead to hallucinations. With grounding, you provide the AI with specific, reliable information to reference, resulting in more accurate and trustworthy responses.

Simple example:

• Without grounding: You ask "What is our company's refund policy?" → AI generates a generic answer that might be wrong
• With grounding: You attach your company's policy document and ask the same question → AI references the actual document and provides an accurate answer

💡 Practical tip: When accuracy matters, upload relevant documents or use AI tools with web search capabilities rather than relying on the AI's training data alone.

Module 8: Multimodal and Additional AI Features

Beyond Text: Multimodal Capabilities

Modern AI assistants can process more than just text. Multimodal means the ability to work with multiple types of input:

• Text — Traditional prompts and responses
• Images — Analyzing, describing, or generating images
• Code — Understanding and generating code
• Documents — Processing PDFs, spreadsheets, presentations
• Audio/Video — Some models can process these formats

Vision Capabilities

Many AI assistants can now "see" and analyze images. This enables:

Image Analysis

• Describe what's in an image
• Read text from screenshots
• Identify objects, people, scenes
• Analyze charts and graphs

Practical Use Cases

1. Implementing UI from Designs

You can share screenshots from Figma or other design tools:

Here's a screenshot of a form design from Figma.
Help me implement this using React and Tailwind CSS.
Focus on matching the layout and spacing.

2. Debugging Visual Issues

Share a screenshot of a bug:

This dropdown menu is rendering incorrectly.
[screenshot]
The options should appear below the button, not overlapping it.
Here's my CSS. What might cause this?

3. Understanding Unfamiliar Interfaces

When navigating new or complex software:

I need to export my project as a PDF but can't find the option.
[screenshot of the application menu]
Where is the export feature in this interface?

Web Search Integration

Many AI assistants can search the Internet for current information. This helps with:

• Current events — News, recent developments
• Up-to-date documentation — Latest API versions
• Research — Finding relevant resources
• Fact-checking — Verifying claims

Using Search Effectively

For research tasks:

Search for recent articles about TypeScript 5.0 features.
Summarize the key improvements for frontend developers.

For verification:

What is the current stable version of Node.js?
Search for the official release information.

Document Processing

AI can analyze various document types:

• PDFs — Extract and analyze text content
• Spreadsheets — Understand data and formulas
• Code files — Review and explain code
• Text documents — Summarize and extract information

Example

I've attached a requirements document (PDF).
Please:
1. Summarize the main functional requirements
2. List any technical constraints mentioned
3. Identify any ambiguous requirements that need clarification

Use Cases for IT Professionals

Use Case 1: UI Implementation Acceleration

Scenario: You need to implement a complex form from a Figma design.

[attach screenshot from Figma]

Please create a React component for this form.
Requirements:
- Use TypeScript
- Use Tailwind CSS for styling
- Include form validation
- Make it accessible (ARIA labels)

Match the design as closely as possible.

Use Case 2: Research and Documentation

Scenario: You need to research best practices for a technical decision.

Search for current best practices for API rate limiting
in Node.js Express applications.

Focus on:
1. Common approaches and their trade-offs
2. Recommended libraries
3. Configuration recommendations for production

Summarize your findings with practical recommendations.

Use Case 3: Analyzing Error Screenshots

Scenario: A user reports an error with only a screenshot.

[attach error screenshot]

Based on this error message:
1. What is the likely cause?
2. What additional information would help diagnose this?
3. What are possible solutions?

Feature Awareness

Different AI tools have different capabilities. Know what your tools can do:

Module 9: Use Cases by Role

Prompts for Every IT Role

This module provides practical prompt templates tailored to different roles in IT teams. Adapt these to your specific needs and context.

For Business Analysts (BA)

Requirement Clarification

I'm documenting requirements for a user registration feature.
The stakeholder said: "Users should be able to sign up easily."

Help me break this into specific, testable requirements.
Consider:
- Required fields
- Validation rules
- User experience flows
- Edge cases

User Story Writing

Write user stories for an e-commerce checkout process.

Context:
- Multi-step checkout (cart → shipping → payment → confirmation)
- Support for guest and registered users
- Multiple payment methods

Format each as:
As a [user type], I want [action] so that [benefit].
Include acceptance criteria.

Stakeholder Communication

I need to explain a 2-week delay in the project timeline.

Causes:
- Unexpected integration complexity
- Team member illness (3 days)
- Scope clarification needed

Help me draft a professional email to stakeholders that:
- Explains the situation clearly
- Proposes mitigation steps
- Maintains confidence in the project

For UX Designers

Usability Review

Review this form design for usability issues:

[describe or attach form]

Consider:
- Field labels and instructions
- Error handling
- Mobile experience
- Accessibility
- Cognitive load

Provide specific, actionable recommendations.

User Flow Documentation

Create a user flow for password reset functionality.

Requirements:
- User can reset via email link
- Links expire after 24 hours
- User must create password meeting security requirements

Format as numbered steps with decision points noted.

For Backend Developers

Code Review Preparation

Review this Python function for:
- Code quality and readability
- Potential bugs
- Performance issues
- Security concerns

[paste code]

Provide specific suggestions with code examples.

API Design

Design a REST API for a task management system.

Entities: Users, Projects, Tasks, Comments
Requirements:
- Users can belong to multiple projects
- Tasks are assigned to users within projects
- Tasks have status (todo, in_progress, done)

Provide endpoints with:
- HTTP methods
- URL paths
- Request/response structure
- Authentication requirements

Debugging Assistance

This function should return filtered results but returns
an empty array.

Expected: Array of items where status = "active"
Actual: Empty array

Code:
[paste code]

Database query returns correct results when run directly.
What might cause this issue?

For Frontend Developers

Component Implementation

Create a React component for a dropdown select.

Requirements:
- Accepts options as props (array of {value, label})
- Supports single selection
- Keyboard navigable
- Accessible (ARIA)
- Styled with Tailwind CSS

Include TypeScript types.

CSS Problem Solving

I have a flexbox layout issue:

[describe layout or paste code]

Problem: Items don't wrap correctly on smaller screens.
Expected: 3 items per row on desktop, 1 on mobile.

What's wrong and how do I fix it?

Performance Optimization

This React component re-renders too frequently.

[paste component code]

Identify:
1. What's causing unnecessary re-renders
2. Optimization strategies (useMemo, useCallback, etc.)
3. Implementation of the fixes

For DevOps Engineers

Configuration Review

Review this Docker Compose configuration for issues:

[paste docker-compose.yml]

Check for:
- Security concerns
- Best practices violations
- Missing health checks
- Resource limits
- Networking issues

Documentation Generation

Create documentation for this CI/CD pipeline:

[paste pipeline configuration]

Include:
- Pipeline overview
- Stage descriptions
- Required environment variables
- Troubleshooting common failures

Troubleshooting

Our Kubernetes pods are in CrashLoopBackOff.

kubectl logs output:
[paste logs]

kubectl describe pod output:
[paste relevant section]

What's the likely cause and how do I diagnose further?

For QA Engineers

Test Case Generation

Generate test cases for a login feature.

Functionality:
- Email and password authentication
- "Remember me" option
- Forgot password link
- Account lockout after 5 failed attempts

Include:
- Positive cases
- Negative cases
- Edge cases
- Security-related tests

Format as a test case table.

Bug Report Improvement

Improve this bug report for clarity:

"Login doesn't work sometimes."

Help me rewrite it with:
- Clear steps to reproduce
- Expected vs actual results
- Environment details needed
- Severity assessment

Test Data Generation

Generate test data for user registration testing.

I need 10 test cases covering:
- Valid inputs
- Invalid emails
- Password validation failures
- Edge cases (long names, special characters)

Format as a table with: name, email, password, expected_result

For Architects

Design Decision Documentation

Document the decision to use PostgreSQL over MongoDB
for our e-commerce platform.

Context: High transaction volume, complex queries,
need for ACID compliance.

Format as an Architecture Decision Record (ADR):
- Title
- Status
- Context
- Decision
- Consequences

System Design Review

Review this system architecture for a real-time
messaging application:

[describe architecture]

Evaluate:
- Scalability
- Single points of failure
- Performance bottlenecks
- Security concerns

Provide specific recommendations.

For Data Engineers

Query Optimization

This SQL query runs slowly (>30 seconds):

[paste query]

Table sizes:
- orders: 10M rows
- customers: 500K rows
- products: 50K rows

Suggest optimizations:
- Query restructuring
- Index recommendations
- Execution plan analysis

Data Pipeline Documentation

Document this ETL pipeline:

Source: [describe]
Transformation: [describe]
Destination: [describe]

Include:
- Pipeline overview
- Data flow diagram (describe for me to create)
- Error handling
- Scheduling
- Monitoring approach

For Project Managers

Status Report

Create a project status report from these notes:

Completed this week:
- User authentication module
- Database schema finalized

In progress:
- Payment integration (50%)
- Admin dashboard (30%)

Blockers:
- Waiting for API credentials from payment provider

Format for executive stakeholders: concise, highlight risks.

Meeting Facilitation

I'm facilitating a sprint retrospective.

Team size: 6 developers, 1 QA
Sprint outcome: Delivered 80% of planned items

Help me create:
1. Opening questions to encourage participation
2. Discussion prompts for what went well/poorly
3. Action item template
4. Time allocation for 60-minute meeting

Module 10: Practical Workshop (Optional)

Hands-On Practice

This module is designed for practical application. Complete these exercises to build confidence in your AI skills.

📝 Note: Practice these exercises in your approved AI tool. Save prompts that work well for future reference.

Exercise 1: Writing an Effective Prompt

Task: Transform a weak prompt into an effective one.

Weak Prompt:

Explain microservices.

Your Task: Rewrite this prompt to be more effective. Consider:

• Who is the audience?
• What specific aspects of microservices?
• What format would be most useful?
• How long/detailed should the response be?

Example Strong Version:

Explain microservices architecture to a developer
who has only worked with monolithic applications.

Cover:
1. Core concept and benefits
2. How microservices differ from monoliths
3. When to consider microservices
4. Key challenges to expect

Keep the explanation concise (under 500 words).
Use practical examples.

Exercise 2: Providing Context

Task: Add appropriate context to improve AI output.

Scenario: You're debugging a JavaScript function.

Prompt Without Context:

Why isn't this working?

function getData() {
  const data = fetch('/api/data');
  return data;
}

Your Task: Rewrite with necessary context. What information would help the AI diagnose the issue?

Exercise 3: Critical Evaluation

Task: Evaluate an AI response for potential issues.

Prompt:

What's the best JavaScript framework in 2024?

AI Response:

The best JavaScript framework in 2024 is definitely React.
It has 95% market share and is used by 100% of Fortune 500
companies. Studies from MIT show React is 10x faster than
any alternative.

Your Task: Identify the red flags in this response. What should you verify? What's likely fabricated?

Exercise 4: Iterative Improvement

Task: Practice refining an AI response through iteration.

Initial Prompt:

Write a function to validate an email address.

If the AI's response isn't exactly what you need, practice:

1. Asking for specific changes
2. Providing additional requirements
3. Requesting a different approach

Possible Follow-ups:

• "Make it TypeScript with proper types"
• "Add support for catching common typos like missing @ symbol"
• "Include test cases for the function"

Exercise 5: Role-Based Prompt

Task: Create a prompt using the role technique.

Your Task: Write a prompt that assigns the AI a specific role for your work context. For example:

Act as a senior [your role] conducting code review.

Review this [code/design/document]:
[your content]

Focus on:
1. [Aspect 1]
2. [Aspect 2]
3. [Aspect 3]

Provide specific, actionable feedback.

Self-Assessment Checklist

After completing the exercises, verify you can:

Starter Competency Check
════════════════════════

☐ Write clear, structured prompts
☐ Provide relevant context without overloading
☐ Specify desired output format
☐ Identify red flags in AI responses
☐ Verify critical information before using it
☐ Adapt prompts when initial results aren't ideal
☐ Apply security guidelines when using AI
☐ Use role prompting effectively

Module 11: Exam and Summary

Course Recap

Congratulations on completing AI Growth Path: Foundation! Let's review what you've learned.

Core Principles Covered

1. AI is Your Assistant — You remain the expert and final authority

2. Human Oversight — Always keep a human in the loop for verification

3. Communicate with Precision — Quality inputs drive quality outputs

4. Protect Sensitive Information — Never share confidential data (with documented exceptions for client-approved tools and organization-licensed services)

5. Verify All Outputs — Never trust AI outputs blindly

6. Ground AI in Reliable Sources — Anchor AI in verified documentation

Exam Preparation

The final exam will test your understanding of:

1. Knowledge of GenAI fundamentals — How models work, hallucinations, limitations
2. Security principles — What to protect, approved usage guidelines, when exceptions apply
3. Prompt engineering basics — Clear prompts, context, format specification
4. Critical thinking — Evaluating outputs, identifying errors, verification

Your Next Steps: The Path Forward

Practitioner Level

At the Practitioner level, you'll advance to:

• Effective AI Dialogue — Iterative conversations, refinement techniques
• Personal Workflows — Building AI-assisted processes for your role
• Tool Mastery — Understanding different AI tools and their strengths
• Advanced Prompting — Chain-of-thought, complex multi-step tasks

Expert Level

At the Expert level, you'll become:

• An AI Process Designer — Creating reusable AI workflows for teams
• A Strategic Advisor — Evaluating costs, benefits, and tool selection
• A Mentor — Teaching and guiding others in AI adoption

Further learning: recommended materials

If you would like to deepen your understanding of Generative AI beyond the Starter level, we recommend the following materials:

1. Introduction to Generative AI – Google A clear, well-structured introduction to Generative AI concepts, capabilities, and limitations, suitable for both technical and non-technical professionals.
2. ChatGPT – czy to magia? Świat AI w pigułce - Krzysztof Kąkol [PL only] A concise, accessible overview of AI and ChatGPT, placing modern AI tools in a broader context and explaining how they really work behind the scenes.

These resources are optional, but highly recommended for anyone preparing for the Practitioner level.

Final Thoughts

You've taken an important first step. Remember:

• Start small — Apply what you've learned to simple tasks first
• Practice regularly — Skill develops through consistent use
• Stay curious — The AI landscape evolves rapidly
• Share knowledge — Help your teammates grow too

The goal isn't to use AI for everything — it's to know when and how AI can make you more effective while maintaining quality and security.

Ready to take the exam? Good luck!