The everyday computer, internet, safety and AI skills every tech and STEM job assumes you already have.

Digital Literacy for Tech & STEM Work

Choose a factual question from your field with a checkable answer (for example: 'What is the default port for HTTPS?', 'What does the pandas dropna function do by default?', or 'What does OSHA say about using GFCIs on construction sites?').

Ask the AI assistant the question and copy its answer into your notes.

Find the primary source: official documentation, a standard, the regulator's website, or a textbook. Write down its URL or reference.

Compare the two answers line by line and mark each claim as correct, wrong, missing detail, or cannot verify.

If it is safe and possible, test the claim yourself (run the code on a copy, or try it in a spreadsheet).

Ask the AI a follow-up that challenges its answer with what you found, and note how it responds.

Write a one-paragraph verdict: how accurate was it, and what would have happened if you had trusted it without checking?

## Why it matters

AI assistants (chatbots built on large language models, such as ChatGPT, Claude, Gemini and Copilot) are now part of everyday technical work. They draft emails, explain error messages, suggest code and summarise documents. They can save a lot of time. They can also state wrong things with complete confidence. People who get the most from them know what the tools are good at, where they fail, and how to check the output.

## The core idea: very good prediction, not a database of facts

A **large language model (LLM)** is trained on a huge amount of text. It learns statistical patterns in language and uses them to predict, one small piece of text (a *token*) at a time, what is likely to come next. Fine-tuning then teaches it to follow instructions and respond helpfully.

This explains both its strengths and its weaknesses:

- It is excellent at **language tasks**: rewording, summarising, explaining, translating, drafting, and producing text in a requested format.
- It does **not look facts up** by default. It generates what *sounds* right. When the right answer was rare or absent in its training, it may produce a fluent, plausible and wrong answer. This is often called a **hallucination**.

Some assistants can search the web or read files you give them, which helps, but they can still misread or misquote sources.

## What they are good at

- Explaining a concept in simpler words, or at a different level.
- Explaining what an error message usually means and suggesting things to check.
- Drafting: emails, outlines, documentation, test cases, starter code.
- Reformatting: turning notes into a table, converting units of text into a checklist.
- Brainstorming options you can then evaluate.

## Where they go wrong

- **Invented details:** made-up function names, settings, citations, statistics, legal clauses or paper titles.
- **Out-of-date knowledge:** models have a training cut-off date. New versions of tools, standards and prices may be missing.
- **Maths and counting:** they can slip on arithmetic, units and long calculations unless they use a calculator or code tool.
- **Agreeing with you:** a leading question ("this is right, isn't it?") often gets agreement.
- **Safety-critical advice:** electrical work, lab procedures, medication, structural loads, legal requirements. Wrong answers here can hurt people.

## Rules for using AI at work and in study

1. **You are responsible for what you use.** "The AI said so" is not an excuse for a wrong number, insecure code or a false claim.
2. **Verify against a trusted source:** official documentation, a standard, a textbook, your instructor, or a test you run yourself.
3. **Protect data.** Do not paste passwords, API keys, customer or patient data, unpublished research, or confidential code into AI tools unless your organisation has approved that tool for that data.
4. **Follow the rules where you are.** Schools and employers have AI policies; some courses and exams forbid AI help. Be open about how you used it when asked.
5. **Use it to learn, not to skip learning.** Ask it to explain *why*, then try the next problem yourself.

## Worked example: checking an AI answer

You ask an assistant: *"In Excel, what does XLOOKUP return if no match is found?"*

It replies: *"XLOOKUP returns 0 when no match is found."*

How to check:

1. **Find the primary source.** Search `XLOOKUP site:support.microsoft.com` and open Microsoft's documentation for the function.
2. **Compare.** The documentation explains that if no match is found, XLOOKUP returns the `#N/A` error, unless you supply the optional `if_not_found` argument, in which case it returns that value instead.
3. **Test it.** In a spreadsheet:

```text
A1:A3 = apple, banana, cherry      B1:B3 = 1, 2, 3
=XLOOKUP("grape", A1:A3, B1:B3)              ->  #N/A
=XLOOKUP("grape", A1:A3, B1:B3, "not found")  ->  not found
```

4. **Conclusion:** the AI's answer was wrong. Note the correct behaviour and the source.

The same habit works for code: read the suggestion, check unfamiliar functions in the official docs, and run it on a safe test before trusting it.

## Common mistakes

- Treating an AI answer as a source to cite. Cite the documentation or paper you verified instead, and check that any references the AI gives actually exist.
- Pasting confidential data into a public tool.
- Copying code you do not understand into a real project.
- Asking leading questions and taking agreement as confirmation.
- Letting AI do all of your practice exercises, then struggling in an interview or on the job.

## Quick recap

- LLMs predict likely text; they are strong at language tasks and can be confidently wrong.
- Watch for invented details, out-of-date facts, maths slips and agreement with leading questions.
- Verify with primary sources or your own test; protect confidential data; follow local AI policies.
- Use AI to speed up learning, not to replace it.

## Try it

Open the Do tab to check a real AI answer against a trusted source.


Understand how AI chat assistants produce answers, where they go wrong, and how to check one against a trusted source.

What AI assistants can and can't do

Large Language Models explained briefly

Choose where your notes will live and create a section or folder for this course.

Create a lesson note template with these headings: Key ideas (in my own words), Example I worked through, Questions to test myself, Still confused about, Links.

Fill in a note for one lesson you have already finished in this course, writing from memory first and checking the lesson only afterwards.

Write three self-test questions in that note.

Pick three study slots for the coming week and put them in your calendar with a reminder.

At the start of your next session, answer your three questions without looking, then check and correct your note.

## Why it matters

Online learning is flexible, free and huge, which is exactly why it is easy to watch hours of videos and remember little. Every career on this platform keeps changing, so learning new tools on your own is a skill you will use for your whole working life. A few habits, backed by solid learning research, make the time you spend count.

## The core idea: retrieve, space, apply

Three ideas from learning science do most of the work:

- **Retrieval practice:** pulling information *out* of your memory (answering a question, explaining from memory, solving a problem) strengthens it far more than reading it again. Quizzes are a learning tool, not just a test.
- **Spaced practice:** reviewing something a day later, then a few days later, then a week later beats one long session. Cramming feels productive but fades quickly.
- **Application:** doing something with the idea (writing code, working a problem, doing a real task) builds understanding that watching cannot.

The trap to avoid is the **illusion of competence**: rewatching or rereading feels familiar, and familiarity feels like knowing. The test is whether you can do it with the material closed.

## A note system that works

You need somewhere to put what you learn, and a way to find it again. Keep it simple; the best system is the one you will keep using.

**Where:** a notes app (for example OneNote, Google Keep, Apple Notes, Notion or Obsidian), plain Markdown files in a folder, or a paper notebook. If you made the `coding-help-learning` folder earlier in this course, use its `notes` folder.

**Structure:** one folder (or notebook section) per course, one note per lesson, named with the date and lesson:

```text
notes/
  digital-literacy/
    2026-10-23-how-the-internet-works.md
    2026-10-24-searching-and-sources.md
```

**A lesson note template:**

```markdown
## How the internet works (2026-10-23)

### Key ideas (in my own words)
- DNS turns names into IP addresses
- ...

### Example I worked through
...

### Questions to test myself
- What does a 404 mean?
- What does HTTPS protect, and what not?

### Still confused about
- ...

### Links
- lesson URL, docs I used
```

Writing in your own words, rather than copying, is what makes notes useful. The "Questions to test myself" section turns your notes into retrieval practice later.

## Getting more from videos

- **Watch with a goal.** Before pressing play, write the question you want answered.
- **Pause and predict.** Before the instructor shows the answer, pause and try it yourself.
- **Speed is a tool.** Speed up familiar parts, slow down or rewatch hard ones.
- **Code along**, or work the example on paper, instead of only watching.
- **Use captions and transcripts** to search for a part you want again.
- **Afterwards,** close the video and write the three main points from memory.

## A weekly routine

A realistic plan for someone fitting learning around work or school:

| When | What | Time |
|---|---|---|
| 3-4 days a week | one lesson: read or watch, take notes, do the activity | 30-45 min |
| start of each session | answer 3 questions from older notes without looking | 5 min |
| once a week | review the week's notes; redo one exercise from memory | 20 min |
| when stuck | write the exact question, search, then ask in the lesson Q&A or forums | as needed |

Block the time in your calendar like an appointment, and study somewhere with notifications off. Short, regular sessions beat rare long ones.

## Worked example

Jordan watches a 12-minute video on file systems and takes no notes. A week later they remember almost nothing.

The next week Jordan tries the routine: writes the goal ("What is the difference between RAM and storage?"), pauses twice to predict, writes a note in their own words with three self-test questions, and does the lesson activity. Two days later they answer the questions from memory before starting the next lesson, getting one wrong and fixing their note. The same time spent, much more retained.

## Common mistakes

- Rereading and highlighting instead of testing yourself.
- Copying the instructor word for word.
- Collecting courses and bookmarks without finishing any.
- Long, irregular sessions with your phone beside you.
- Never asking for help. Stating your question clearly is a skill, and the forums and lesson Q&A are there for it.

## Quick recap

- Retrieval, spacing and application make learning stick; rereading mostly feels like it does.
- Keep one note per lesson in your own words, with self-test questions.
- Watch videos actively: set a goal, pause, predict, practise.
- A short, regular weekly routine beats occasional marathons.

## Try it

Open the Do tab to set up your own note system and plan your week.


Build a simple note system and study routine that make online courses and videos actually stick.

Learning effectively online

Taking Notes: Crash Course Study Skills #1

Pick a small real task: explaining a concept from this course, drafting a short message, or fixing a tiny piece of practice code.

Write a one-line vague prompt for it, send it, and save the answer in your notes.

Rewrite the prompt with context, task, format and constraints (add an example of the output you want if you can). Send it and save the answer.

Compare the two answers: note what improved and what is still missing.

Send two follow-ups: ask the assistant to list its assumptions, and to point you to the official source for one claim.

Verify the result: run the code on a test, or check each fact against a primary source.

Save your improved prompt as a reusable template in your notes.

## Why it matters

The quality of an AI assistant's answer depends heavily on the question. A vague prompt gets a generic, often unhelpful reply; a specific one gets something you can actually use. Writing a good prompt is the same skill as writing a good question for a colleague, a forum or a support ticket: say what you are trying to do, what you have, and what you need back. And because AI tools can be wrong, every good prompt is followed by a check.

## The core idea: context, task, format, constraints

A useful prompt usually includes four parts:

1. **Context:** who you are and the situation. "I'm a beginner learning Python for lab data." "This is for a maintenance report read by supervisors."
2. **Task:** exactly what you want. "Explain", "Draft", "Find the bug", "Compare", "Summarise in five bullet points".
3. **Format:** how you want it back. A table, a checklist, numbered steps, code with comments, under 150 words.
4. **Constraints:** limits and requirements. "Use only the standard library." "Plain English, no jargon." "Do not change the function names." "Say if you are unsure."

Giving an **example** of the output you want is one of the most effective additions.

## Worked example 1: from vague to specific

Vague:

```text
fix my code
```

Specific:

```text
I'm learning Python. This function should return the average of a list of
numbers, but it crashes on an empty list with ZeroDivisionError.

def average(values):
    return sum(values) / len(values)

Please:
1. Explain in two sentences why it crashes.
2. Show a fixed version that returns None for an empty list.
3. Give two test cases I can run to check it.
Keep the same function name.
```

The second prompt gives the assistant the code, the error, the goal and the format. You will likely get a short explanation, a fix such as:

```python
def average(values):
    if not values:
        return None
    return sum(values) / len(values)
```

and tests you can run yourself, which is the verification step.

## Worked example 2: a writing task

```text
Context: I'm an electrical apprentice writing a short update for my supervisor.
Task: Turn these notes into a clear, polite message.
Format: 3 short paragraphs, under 120 words.
Constraints: Keep all times and room numbers exactly as written; do not add
technical claims that are not in my notes.

Notes: panel B3 labels done, room 214 outlet not working, reported to J at 10:40,
need ladder for 2nd floor tomorrow
```

The constraint "do not add technical claims" matters: AI tools tend to fill gaps with plausible details. Then you read the draft and check every fact against your notes before you send it.

## Iterate, don't start over

Treat the first answer as a draft. Follow up:

- "Shorter, and use bullet points."
- "Explain step 3 as if I've never used a terminal."
- "What assumptions did you make?"
- "What could go wrong with this approach?"
- "Show me where in the official documentation this is described."

Asking the assistant to list its assumptions or to say when it is unsure often surfaces weak spots.

## Verify the output

Before you use any AI output:

- **Code:** read it, look up unfamiliar functions in the official docs, and run it with tests on safe data.
- **Facts and numbers:** check them against a primary source. Check that any links or references exist.
- **Writing:** make sure every claim is true and the tone is right; it goes out under your name.
- **Safety, legal, medical, licensing:** use the official source; AI can only point you towards it.

## Using AI responsibly

- **Never paste secrets** (passwords, API keys, access tokens) or personal, customer, patient or confidential data into a tool your organisation has not approved for that data.
- **Follow course and workplace rules** on AI use, and be honest about how you used it.
- **Keep learning:** ask for hints or explanations rather than full solutions when you are practising.

## Common mistakes

- One-line prompts with no context, then blaming the tool.
- Asking several unrelated questions in one prompt.
- Leading questions ("This is correct, right?") that invite agreement.
- Accepting the first answer without follow-up or checks.
- Pasting confidential data to "give context".

## Quick recap

- Good prompts give context, a precise task, a format and constraints, ideally with an example.
- Iterate with follow-ups instead of starting over.
- Verify everything: run code, check facts against primary sources, reread writing.
- Protect data and follow the AI rules where you study and work.

## Try it

Open the Do tab to write, improve and verify a prompt of your own.


Write specific prompts with context, a clear task and a format, then verify the output before you use it.

Asking AI good questions

How to write an AI prompt

Behind the prompt: Prompting tips for Claude.ai

What AI assistants can and can't do, how to learn effectively online, and how to ask AI good questions and check the answers.