Creator prompt
The idea behind this presentation
Act as a professional ICT/Computer teacher and instructional designer. Create a complete teaching presentation and lesson material about **Introduction to HTML** for beginner students.
The lesson must be designed for a total class duration of **60 minutes**:
- **45 minutes** for classroom discussion and teacher-led demonstration
- **15 minutes** for a HANDS-ON coding activity using an actual computer
Do not place time labels such as “5 minutes,” “10 minutes,” “45 minutes,” or “15 minutes” on the actual presentation slides. Use the timing only when deciding how much content to prepare.
# IMPORTANT SCOPE
Focus **ONLY on HTML**.
Do NOT discuss:
- CSS
- JavaScript
- Styling
- Responsive design
- Frameworks
- Backend development
- Advanced web development
The lesson must be purely about **basic HTML**.
# Topic
**Introduction to HTML**
# Target Learners
Assume the students are complete beginners and have little or no previous experience with HTML.
Use:
- Simple English
- Beginner-friendly explanations
- Layman’s terms
- Short examples
- Clear demonstrations
- Real-life analogies when helpful
Avoid deep technical explanations unless they are necessary. If a technical term is introduced, immediately explain it in simple language.
# Learning Objectives
By the end of the lesson, students should be able to:
1. Explain what HTML is.
2. Explain what HTML is used for.
3. Explain why HTML is a markup language and not a programming language.
4. Differentiate a markup language from a programming language in simple terms.
5. Identify the basic structure of an HTML document.
6. Understand HTML tags, elements, and attributes.
7. Use common beginner HTML tags.
8. Create an actual HTML file using a code editor.
9. Save an HTML file correctly.
10. Open and test an HTML webpage using a web browser.
# DISCUSSION CONTENT
Organize the lesson in a natural teaching sequence.
## 1. What is a Webpage?
Briefly explain:
- What a webpage is
- What a website is
- What a web browser is
- How a browser can open and display an HTML file
Keep the discussion focused entirely on HTML.
Do not introduce CSS or JavaScript.
Use a simple explanation such as:
> A webpage is like one page of a digital book. A website is the whole book containing different webpages.
Explain that a web browser such as Google Chrome, Microsoft Edge, or Firefox can read an HTML file and display it as a webpage.
## 2. What is HTML?
Explain that:
**HTML stands for HyperText Markup Language.**
Explain in simple terms:
HTML is a language used to **organize and describe the content of a webpage**.
For example, HTML tells the browser:
- “This is the main heading.”
- “This is a paragraph.”
- “This is an image.”
- “This is a link.”
- “This is a list.”
Explain that HTML provides the **structure and meaning of webpage content**.
Give examples of content that HTML can represent:
- Headings
- Paragraphs
- Images
- Links
- Lists
- Tables
- Forms
Do not go deeply into tables or forms because this is an introductory lesson.
## 3. Why is HTML Called a Markup Language?
This topic is very important.
Explain clearly what the word **markup** means.
### Simple Definition
A markup language uses special tags or symbols to describe and organize information.
For example:
```html
<h1>Welcome Students</h1>
```
Explain:
The words:
`Welcome Students`
are the actual content.
The tags:
`<h1>` and `</h1>`
tell the browser:
**“This content is a main heading.”**
Use this layman’s explanation:
> HTML is like putting labels on different parts of a document.
For example, imagine a teacher has a piece of paper containing:
- School Name
- Student Name
- Introduction
- Hobbies
HTML works like placing labels on those parts:
- “This is a heading.”
- “This is a paragraph.”
- “This is a list.”
- “This is a link.”
The browser reads those labels and understands how the content is organized.
## 4. Markup Language vs. Programming Language
Create a clear beginner-friendly comparison.
Explain that HTML is a **markup language**, not a traditional programming language.
### Markup Language
A markup language mainly:
- Organizes content
- Describes content
- Labels parts of a document
- Gives structure to information
Example:
```html
<h1>My Website</h1>
<p>Welcome to my webpage.</p>
```
HTML tells the browser what the content represents.
### Programming Language
A programming language normally gives a computer instructions to:
- Perform calculations
- Make decisions
- Repeat tasks
- Process information
- Execute different actions
Keep this general.
Do NOT start teaching an actual programming language.
### Layman’s Explanation
Use this analogy:
**Markup Language = Labeling and organizing**
**Programming Language = Giving instructions**
Example:
Imagine you are organizing a classroom.
HTML or a markup language is like placing labels:
- “Teacher's Table”
- “Student Chairs”
- “Books”
- “Whiteboard”
The labels tell you **what things are and how they are organized**.
A programming language would be more like giving instructions:
- “If the bell rings, open the door.”
- “Count the students.”
- “Repeat this task five times.”
Explain:
> HTML mainly describes WHAT the content is. A programming language can tell the computer WHAT TO DO.
Include a simple comparison table:
| Markup Language | Programming Language |
|---|---|
| Describes content | Gives instructions |
| Organizes information | Processes information |
| Uses markup or tags | Uses programming instructions |
| Focuses on structure | Can perform actions and logic |
| HTML is an example | Many programming languages exist |
Do not introduce or teach CSS or JavaScript in this comparison.
The purpose is only to help students understand **why HTML is called a markup language**.
## 5. HTML Files
Explain that HTML documents commonly use the:
`.html`
file extension.
Example:
`index.html`
Explain in simple terms:
> The `.html` extension tells the computer and browser that the file contains HTML.
Explain that `index.html` is commonly used as the main or starting webpage of a simple website.
## 6. How HTML Works
Create a simple process diagram:
**Write HTML → Save as .html → Open in Browser → Browser Displays Webpage**
Explain each step:
1. Write HTML code in a code editor.
2. Save the file using `.html`.
3. Open the HTML file using a web browser.
4. The browser reads the HTML tags.
5. The browser displays the content as a webpage.
Use a real screenshot or simple diagram from a reliable source when appropriate.
Do not generate an AI image for this.
## 7. Basic HTML Document Structure
Introduce this complete example:
```html
<!DOCTYPE html>
<html>
<head>
<title>My First Webpage</title>
</head>
<body>
<h1>Hello World!</h1>
<p>This is my first webpage.</p>
</body>
</html>
```
Explain each part separately and clearly.
### `<!DOCTYPE html>`
Explain simply:
It tells the browser that the document uses modern HTML.
### `<html>`
Explain:
It contains the HTML document.
### `<head>`
Explain:
It contains information about the webpage that is not normally displayed as the main page content.
### `<title>`
Explain:
It controls the text displayed on the browser tab.
Example:
```html
<title>My First Webpage</title>
```
### `<body>`
Explain:
The `<body>` contains the content that students normally see inside the webpage.
Example:
```html
<body>
<h1>Hello!</h1>
<p>Welcome to my webpage.</p>
</body>
```
## 8. HTML Tags
Explain opening and closing tags.
Example:
```html
<p>Hello Students!</p>
```
Break it down visually:
`<p>` = Opening tag
`Hello Students!` = Content
`</p>` = Closing tag
Explain:
Many HTML tags come in pairs.
Use a layman’s explanation:
> Think of tags like containers. The opening tag starts the container, the content goes inside, and the closing tag ends the container.
## 9. HTML Elements
Explain an HTML element.
Example:
```html
<h1>My First Website</h1>
```
Explain:
The whole thing:
```html
<h1>My First Website</h1>
```
is an HTML element.
Clearly differentiate:
**Tag:**
```html
<h1>
```
**Content:**
`My First Website`
**Complete element:**
```html
<h1>My First Website</h1>
```
## 10. HTML Attributes
Introduce attributes using:
```html
<a href="https://www.example.com">Visit Website</a>
```
Explain:
`<a>` = tag
`href` = attribute
`https://www.example.com` = attribute value
`Visit Website` = clickable content
Use a simple explanation:
> An attribute gives additional information to an HTML element.
## 11. HTML Headings
Introduce:
```html
<h1>Heading 1</h1>
<h2>Heading 2</h2>
<h3>Heading 3</h3>
<h4>Heading 4</h4>
<h5>Heading 5</h5>
<h6>Heading 6</h6>
```
Explain:
HTML provides six heading levels.
`<h1>` represents the highest-level or most important heading.
`<h6>` represents the lowest-level heading.
Show an authentic browser screenshot or actual browser output.
## 12. Paragraphs
Introduce:
```html
<p>This is a paragraph.</p>
```
Example:
```html
<p>My name is Juan. I am learning HTML.</p>
```
Explain that `<p>` is used for paragraphs of text.
## 13. Line Break
Introduce:
```html
<br>
```
Example:
```html
<p>
Juan Dela Cruz<br>
Grade 10<br>
Sta. Catalina College
</p>
```
Explain:
`<br>` moves the following content to a new line.
## 14. Horizontal Rule
Introduce:
```html
<hr>
```
Example:
```html
<h1>About Me</h1>
<hr>
<h2>My Hobbies</h2>
```
Explain simply that `<hr>` represents a thematic break between sections and is commonly displayed as a horizontal line.
## 15. Important and Emphasized Text
Introduce:
```html
<strong>Important text</strong>
```
and:
```html
<em>Emphasized text</em>
```
Explain their purpose simply.
Do not introduce CSS styling.
## 16. HTML Links
Introduce:
```html
<a href="https://www.google.com">Visit Google</a>
```
Explain:
- `<a>` creates a hyperlink.
- `href` tells the browser where the link should go.
- The text between the tags becomes clickable.
## 17. HTML Images
Introduce:
```html
<img src="school.jpg" alt="Photo of our school">
```
Explain:
`<img>` = image element
`src` = location or source of the image
`alt` = description of the image
Explain why `alt` is important in simple terms.
Explain that `<img>` does not use a normal closing tag.
## 18. Unordered Lists
Introduce:
```html
<ul>
<li>Gaming</li>
<li>Music</li>
<li>Reading</li>
</ul>
```
Explain:
`<ul>` = unordered list
`<li>` = list item
## 19. Ordered Lists
Introduce:
```html
<ol>
<li>Open the code editor</li>
<li>Create an HTML file</li>
<li>Save the file</li>
<li>Open it in a browser</li>
</ol>
```
Explain the difference:
`<ul>` creates a bulleted list.
`<ol>` creates a numbered list.
## 20. HTML Comments
Introduce:
```html
<!-- This is an HTML comment -->
```
Explain:
Comments are notes inside the HTML source code.
They are normally not displayed on the webpage.
Use a layman’s explanation:
> A comment is like writing a small note to yourself inside your code.
## 21. Creating an Actual HTML File
Demonstrate the complete process using an actual computer.
Use a real code editor such as:
- Visual Studio Code
- Notepad
- Another simple text/code editor
Demonstrate:
1. Open the code editor.
2. Create a new file.
3. Write basic HTML.
4. Click Save As.
5. Name the file:
`index.html`
6. Select an easy-to-find folder.
7. Open the folder.
8. Double-click `index.html`.
9. Open it in a web browser.
10. Return to the editor.
11. Change the HTML.
12. Save the changes.
13. Refresh the browser.
14. Observe the updated webpage.
This should be demonstrated practically rather than only explained theoretically.
## 22. Teacher Coding Demonstration
Perform a live coding demonstration.
Start with:
```html
<!DOCTYPE html>
<html>
<head>
<title>My First Webpage</title>
</head>
<body>
</body>
</html>
```
Then add:
```html
<h1>Welcome to My Webpage</h1>
```
Add:
```html
<p>Hello! My name is Juan.</p>
```
Add:
```html
<h2>My Hobbies</h2>
<ul>
<li>Gaming</li>
<li>Listening to Music</li>
<li>Watching Movies</li>
</ul>
```
Add:
```html
<a href="https://www.google.com">Visit Google</a>
```
After every major change:
1. Save the file.
2. Return to the browser.
3. Refresh the browser.
4. Show students what changed.
This helps students connect the HTML code with the actual browser output.
## 23. Complete Beginner Example
Show:
```html
<!DOCTYPE html>
<html>
<head>
<title>My First Webpage</title>
</head>
<body>
<!-- My first HTML webpage -->
<h1>Welcome to My Webpage</h1>
<p>Hello! My name is Juan Dela Cruz.</p>
<hr>
<h2>About Me</h2>
<p>I am a student learning how to create webpages using HTML.</p>
<h2>My Hobbies</h2>
<ul>
<li>Gaming</li>
<li>Music</li>
<li>Technology</li>
</ul>
<h2>My Favorite Website</h2>
<a href="https://www.google.com">Visit Google</a>
</body>
</html>
```
Explain the example section by section.
Show the actual browser result beside or after the code.
## 24. Common Beginner Mistakes
Include examples.
### Missing Closing Tag
Incorrect:
```html
<p>Hello Students!
```
Correct:
```html
<p>Hello Students!</p>
```
### Wrong File Extension
Incorrect:
`index.txt`
Correct:
`index.html`
### Missing Angle Bracket
Incorrect:
```text
p>Hello</p>
```
Correct:
```html
<p>Hello</p>
```
### Misspelled Tag
Incorrect:
```html
<hl>Hello</hl>
```
Correct:
```html
<h1>Hello</h1>
```
Explain that the correct tag uses the number **1**, not the lowercase letter **L**.
### Forgetting to Save
Explain:
Students must save the HTML file before refreshing the browser if they want to see their latest changes.
## 25. Quick Review
Create approximately five simple review questions.
Examples:
1. What does HTML stand for?
2. Is HTML a markup language or a programming language?
3. In simple terms, what is the main difference between a markup language and a programming language?
4. Which tag contains the visible content of a webpage?
5. What file extension is normally used for an HTML document?
Add the answers in teacher notes or on a separate answer slide.
Do not display the answers immediately on the student question slide.
# HANDS-ON ACTIVITY
## Activity Title
**My First HTML Webpage**
This must be a real **hands-on computer activity**.
Students should NOT simply answer questions on paper.
Each student must:
- Use a computer.
- Open a code editor.
- Type HTML code themselves.
- Save an actual `.html` file.
- Open their file using a real web browser.
- Test their webpage.
- Fix any basic errors they encounter.
## Student Task
Create an HTML webpage about yourself.
Create a new file named:
`index.html`
The webpage must contain:
1. A webpage title using `<title>`
2. One main heading using `<h1>`
3. The student's full name
4. One paragraph introducing themselves
5. A heading called **My Hobbies**
6. At least three hobbies using either `<ul>` or `<ol>`
7. One hyperlink to a website they like
8. One HTML comment
9. One horizontal rule using `<hr>`
10. Proper HTML document structure
## Starter Code
Provide students with this starter structure:
```html
<!DOCTYPE html>
<html>
<head>
<title>My First Webpage</title>
</head>
<body>
<!-- Start your webpage here -->
</body>
</html>
```
Students must complete the content themselves.
## Example Activity Output
Show students an example of the type of webpage they can create, but tell them **not to copy it exactly**.
Example:
```html
<!DOCTYPE html>
<html>
<head>
<title>John's Webpage</title>
</head>
<body>
<!-- About me webpage -->
<h1>Welcome to My Webpage</h1>
<p>
My name is John. I am a student who enjoys learning about computers.
</p>
<hr>
<h2>My Hobbies</h2>
<ul>
<li>Playing games</li>
<li>Listening to music</li>
<li>Watching movies</li>
</ul>
<h2>My Favorite Website</h2>
<a href="https://www.google.com">Visit Google</a>
</body>
</html>
```
## Hands-On Procedure
Students should perform these steps themselves:
1. Open the code editor.
2. Create a new file.
3. Type the HTML starter structure.
4. Add their own information.
5. Save the file as `index.html`.
6. Locate the saved file.
7. Open the file in a browser.
8. Check if their content appears correctly.
9. Return to the code editor if something is incorrect.
10. Correct the HTML.
11. Save again.
12. Refresh the browser.
13. Show the completed webpage to the teacher or submit the HTML file.
## Student Checklist
Before submitting, students should verify:
- My file is named `index.html`.
- My webpage opens in a browser.
- I have a `<title>`.
- I have an `<h1>`.
- I included my name.
- I wrote an introduction paragraph.
- I created a hobbies section.
- My list has at least three items.
- I included one hyperlink.
- I included one HTML comment.
- I used `<hr>`.
- My opening and closing tags are correct.
- I saved my latest changes.
- My webpage displays properly in the browser.
# IMAGE AND VISUAL REQUIREMENTS
**VERY IMPORTANT: Do NOT create or use AI-generated images, illustrations, fake screenshots, or synthetic pictures.**
If the presentation needs visual materials:
- Search the internet for authentic images.
- Use real screenshots.
- Use actual screenshots of HTML code.
- Use actual screenshots of web browsers.
- Use real Visual Studio Code screenshots when appropriate.
- Use diagrams from reliable educational or technical sources.
- Use official logos only when relevant.
Prioritize reliable sources such as:
- MDN Web Docs
- WHATWG HTML Living Standard
- W3C
- Visual Studio Code Documentation
- Reputable universities
- Recognized educational websites
Do not use random images merely to decorate slides.
Every image should help students understand the lesson.
For every externally sourced image or screenshot, include the source URL in:
- Speaker notes,
- Image attribution,
- Or the final references slide.
# TECHNICAL ACCURACY
Use modern **HTML5**.
Verify every code example before putting it in the presentation.
Make sure:
- HTML tags are correct.
- Opening and closing tags are correct.
- Code indentation is readable.
- Examples work when saved as `.html`.
- Explanations are technically accurate.
- The distinction between markup language and programming language is accurate but explained simply.
- No outdated HTML presentation/styling techniques are taught.
Do NOT introduce CSS or JavaScript anywhere in the lesson.
# PRESENTATION DESIGN
Use a clean, professional, modern technology/classroom presentation style.
The slides should be:
- Beginner-friendly
- Easy to read
- Suitable for classroom projection
- Consistent
- Visually clean
- Not overcrowded
Code must use a large enough font to be readable from the back of a classroom.
Avoid long paragraphs.
Prefer:
- Short explanations
- Simple diagrams
- Real screenshots
- HTML code examples
- Browser output examples
- Before-and-after code demonstrations
# SUGGESTED SLIDE SEQUENCE
1. Introduction to HTML
2. Learning Objectives
3. What is a Webpage?
4. What is HTML?
5. What Does “Markup” Mean?
6. Why HTML is a Markup Language
7. Markup Language vs. Programming Language
8. Layman’s Example: Labels vs. Instructions
9. HTML Files and `.html`
10. How HTML Works
11. Basic HTML Document Structure
12. Understanding `<html>`
13. Understanding `<head>` and `<title>`
14. Understanding `<body>`
15. HTML Tags
16. HTML Elements
17. HTML Attributes
18. HTML Headings
19. HTML Paragraphs
20. Line Breaks and Horizontal Rules
21. Strong and Emphasis
22. HTML Links
23. HTML Images
24. Unordered Lists
25. Ordered Lists
26. HTML Comments
27. Creating and Saving an HTML File
28. Teacher Live Coding Demonstration
29. Complete HTML Webpage Example
30. Code vs. Browser Output
31. Common Beginner Mistakes
32. Quick Review
33. Hands-On Activity Instructions
34. Activity Starter Code
35. Activity Requirements
36. Student Checklist
37. Key Takeaways
38. References
You may adjust the number of slides if necessary, but create enough meaningful content to support approximately **45 minutes of actual teaching and demonstration**.
After the discussion, students must complete the **15-minute hands-on HTML coding activity using a computer, code editor, and web browser**.
The most important requirements are:
**Teach HTML only.**
**Clearly explain why HTML is a markup language rather than a programming language.**
**Use layman’s explanations and relatable examples.**
**Make the student activity an actual hands-on HTML coding exercise.**
**Do not discuss CSS or JavaScript.**
**Do not use AI-generated images. Use authentic internet resources and reliable technical references instead.**
Follow Design: {"palette":["HTML Clementine #E44D26 — semantic markup accents and tag highlights","Deep Editor Slate #0F172A — primary headings, high-contrast copy, and code surfaces","Browser Canvas #F8FAFC — high-visibility classroom projection background","Card Surface White #FFFFFF — isolated example cards and browser preview frames","Inspector Cyan #0284C7 — hyperlinks, structural attributes, and browser tab headers","Success Mint #059669 — valid code badges and verified output indicators"],"fonts":{"Plus Jakarta Sans":"https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:ital,wght@0,200..800;1,200..800&display=swap","Inter":"https://fonts.googleapis.com/css2?family=Inter:ital,wght@0,100..900;1,100..900&display=swap","JetBrains Mono":"https://fonts.googleapis.com/css2?family=JetBrains+Mono:ital,wght@0,100..800;1,100..800&display=swap"},"type":"Plus Jakarta Sans in Bold and SemiBold (36pt–44pt) for commanding slide headers and concept anchors; Inter in Regular and Medium (18pt–22pt) with 1.4 line-height for highly legible explanations and analogy labels; JetBrains Mono (20pt–26pt) with distinct ligatures for syntax blocks, tag breakdowns, and code-versus-output comparisons.","layout":"12-column responsive presentation grid with wide 64px gutters optimized for classroom projectors. Employs split-screen 50/50 side-by-side viewports comparing raw HTML on the left with simulated live browser renders on the right, punctuated by persistent top-right concept pill markers ('Concept', 'Live Demo', 'Mistake Watch', 'Hands-On').","framework_treatment":"Crisp simulated browser chrome windows complete with mock URL bars and tab headers for output slides; dark VS Code-inspired containers with subtle 1px slate borders for code snippets; colored anatomical callout chips pointing directly to opening tags, content, and closing tags; light-tinted analogic comparison tables with generous padding.","feels_like":"A polished MDN Web Docs classroom workshop merged with a high-resolution Visual Studio Code live-stream"}