出海数字营销宝典 Logo
出海数字营销宝典evaoo.com

12 Essential Web Terms for Frontend Vibe Coding

2026-08-20Nuyoah (@nanyuan0412)13 min read

12 Essential Web Terms for Frontend Vibe Coding12 Essential Web Terms for Frontend Vibe Coding

When doing frontend Vibe Coding, people without a computer science background most often get stuck on expression: they know exactly what visual or interactive result they want, yet cannot name the corresponding part of the web page, causing the AI to repeatedly modify the wrong layer.

This guide organizes 12 foundational frontend web terms covering UI structure, visual layout, runtime state, and page metadata—each paired with a structural diagram and a copy-ready instruction you can send straight to your Agent.


01 | Frontend: The Layer Users Directly Touch

Frontend refers to the interface layer that users can directly see, click, and type into inside a web page, mini-program, or desktop application.

The title, input fields, submit button, loading spinner, success toast, and error messages on a login page all belong to the frontend.

Showing "Login successful" on the frontend does not guarantee the account actually passed verification. Whether the password is valid, whether the user has permission, and whether the record is persisted to the database depend on the real result returned by the backend.

When an Agent replies "Frontend is done," follow up with one question: has the page merely rendered, or have clicking, submitting, success, and failure states all been verified?

Frontend architecture and client-backend communication diagramFrontend architecture and client-backend communication diagram

Diagram Note: Everything inside the browser—content display, input and clicks, in-progress feedback, and outcome states—belongs to the frontend. The backend on the right handles validation, permissions, and storage; the two sides communicate through requests and responses.

Copy-ready instruction for your Agent:

TEXT1 lines
1Inspect the frontend flow of this login page: input, click, loading, success, and error states must all be genuinely visible and verifiable—do not just confirm that the page renders.

02 | HTML: What Content Exists on the Page and What Each Piece Means

HTML defines the content structure and semantics of a web page. Those angle-bracket < > tags you see in page source code are HTML; browsers read those tags to build the page structure.

Headings, paragraphs, images, links, forms, buttons, and inputs are all declared in HTML to tell the browser which elements exist on the page and how they relate hierarchically.

For example, article titles use heading tags, page navigation uses link tags, and form submissions use button tags. Even though CSS can style them to look identical, they behave completely differently for keyboard navigation, screen readers, search engine parsing, and default browser actions.

HTML only describes content structure and meaning—it does not control colors, spacing, or visual appearance, nor does it execute business logic after a click. Visual styling and interactive behavior belong to CSS and JavaScript, respectively.

If a paragraph is missing, heading hierarchy is broken, or a button sits in the wrong container, inspect HTML first instead of patching CSS.

How to instruct your Agent:

TEXT1 lines
1Inspect the HTML structure of this article: verify that the main page title uses the proper heading element, "View Source" uses a real link, submit actions use button elements, and preserve all existing visual styles.

03 | CSS: Visual Appearance and Responsive Layout

CSS controls a web page's visual appearance, layout geometry, and responsive adaptation across different screen widths.

Colors, font families, font sizes, spacing, border radii, shadows, alignment, and switching from a three-column desktop grid to a single-column mobile stack are all governed by CSS.

Sometimes a button already exists in HTML and clicks properly, yet renders gray or overflows the viewport on mobile. That usually happens because another CSS rule overrode its color or width—not because the button itself is missing.

The "C" in CSS stands for Cascading. A single element can match multiple style rules simultaneously, and the browser computes the final style based on selector scope, specificity, and source order.

CSS cascading styles and visual presentation diagramCSS cascading styles and visual presentation diagram

Diagram Note: On the left, HTML uses tags to establish the heading, body copy, and button; on the right, CSS adjusts colors, spacing, and visual hierarchy while preserving the underlying content structure.

When styling looks wrong, do not tell the Agent to rewrite click handlers—ask it to inspect which CSS rule won and which rule got overridden.

Copy-ready prompt for your Agent:

TEXT1 lines
1This primary button is clickable, but it still renders gray. Inspect the CSS rules matching it and its final computed styles, find the declaration overriding the theme color, and do not alter the HTML structure or click behavior.

04 | Markdown: Writing Structured Text with Simple Symbols

Markdown is a lightweight markup language—at its core, plain text annotated with simple structural symbols.

The #, -, **, and triple backticks you routinely see in AI chat windows, project READMEs, or note apps are Markdown syntax.

It uses minimal characters to mark headings, lists, bold text, links, and code blocks. The source file itself remains plain text; only after a Markdown-capable tool renders it does it turn into a cleanly formatted reading view.

Pasting the exact same Markdown snippet into different apps can produce different output. Some editors support tables, task lists, and footnotes; some only parse basic headings and lists; others perform no rendering and display the raw symbols literally.

Markdown excels at writing documentation and maintaining clean text hierarchy. When you need pixel-accurate visual design on the web, you still need HTML, CSS, and JavaScript.

Comparison of plain-text Markdown source and rendered viewComparison of plain-text Markdown source and rendered view

Diagram Note: On the left, #, -, **, and backticks remain plain-text symbols; once rendered, they become the page on the right with headings, bullet lists, emphasis, and code blocks.

Copy-ready instruction for your Agent:

TEXT1 lines
1Format this documentation in Markdown: use headings for hierarchy, lists for steps, and code blocks for commands. Afterward, verify the rendered output and make sure every code fence is properly closed.

05 | Component: Reusable Interface Building Blocks

A Component bundles a piece of UI together with its associated interactive behavior so it can be reused across multiple pages. Updating the component master updates every instance that references it in sync.

For instance, if the homepage, search results page, and favorites page all display product cards—each containing an image, product title, price, and favorite button—that entire block should be extracted into a Product Card component.

Later, if you want to change the price format from "899 USD" to "$899", you only edit that single component and all three pages update automatically.

Components should encapsulate UI modules with clear boundaries that appear repeatedly and need unified maintenance—there is no need to split an entire page or every isolated line of text into a separate component.

Component master and reusable instances diagramComponent master and reusable instances diagram

Diagram Note: A single component master renders three structurally consistent product cards. When button styling or price formatting changes later, editing the master updates every instance at once without touching all three pages individually.

Copy-ready instruction for your Agent:

TEXT1 lines
1The homepage, search page, and favorites page all use the same product card. Refactor it into a reusable Component while keeping each page able to pass in different product data.

06 | State: Dynamic Data Changes Remembered by the Interface

State is the data that the UI currently holds in memory and updates in response to user actions or API responses.

When a submit button first loads and is clickable, that is the default state; after clicking, it turns into "Saving..."—the loading state; when the API succeeds it displays "Saved," and on failure it shows an error message with a retry action. All of these are distinct States.

Whether a modal is open or closed, how many items are in the cart, and which filter tab is currently selected are all part of State.

Frontend state is not the same as backend database persistence. Seeing the UI state flip to "Saved" does not mean the server actually wrote the record. If your changes vanish after refreshing the browser, the code only updated temporary frontend state without persisting data.

State machine and operation lifecycle transition diagramState machine and operation lifecycle transition diagram

Diagram Note: A single submit control transitions sequentially through default, saving, success, and failure states. State transitions must follow the actual API response rather than showing success immediately on click.

How to instruct your Agent:

TEXT1 lines
1Check the State flow for saving: enter a saving state immediately on click, show "Saved" only after the request succeeds, display an error with a retry action on failure, and block duplicate submissions while in flight.

07 | DOM: The Live Node Tree in the Browser at Runtime

DOM stands for Document Object Model. After the browser parses HTML, it organizes headings, paragraphs, buttons, and lists into a programmable tree of nodes—that tree is the DOM.

The runtime DOM does not always match the initial HTML source file.

For example, suppose the source HTML file contains only one task item. After the user clicks "Add," JavaScript inserts a second task node into the DOM. You see the new task on screen, even though that line never existed in the original HTML file.

DOM updates only mean the page currently sitting in browser memory changed. Whether the new item survives a page refresh depends on whether the data was saved to browser storage (LocalStorage / IndexedDB) or a backend database.

Runtime DOM tree with dynamically inserted nodesRuntime DOM tree with dynamically inserted nodes

Diagram Note: On the left is the initial HTML file; on the right is the browser's runtime DOM. The orange LI is a new node dynamically inserted by JavaScript—it appears immediately on the page, but whether it persists across reloads depends on separate storage.

Copy-ready prompt for your Agent:

TEXT1 lines
1Clicking Add renders a new task on screen, even though it isn't in the source HTML. Inspect what node was inserted into the runtime DOM, then verify whether the data is genuinely persisted and survives a page refresh.

08 | Title Tag: The Page Title Shown in Browser Tabs

The Title Tag is the page title element placed inside the HTML document's <head> section.

Its most immediate job is displaying the current page's name in the browser's top tab bar. Search engines also use it when generating search result titles, sometimes rewriting it based on the user's query.

The Title Tag and the visible <h1> heading inside the page body are two separate elements.

For example, a product detail page's body <h1> might read concisely as "Massage Chair," while its Title Tag reads "Massage Chair | Sihoo 300"—helping users tell products and sites apart at a glance across dozens of open tabs.

If every product page hardcodes its Title Tag to "Product Details," then even if every body <h1> is unique, users switching browser tabs still cannot tell which tab is which.

Comparison between Title Tag and body H1 headingComparison between Title Tag and body H1 heading

Diagram Note: The browser tab label at the top comes from the Title Tag, while "Massage Chair" in the page body comes from H1. Their copy can be related, but they live in different parts of the code and must be configured and verified separately.

Copy-ready instruction for your Agent:

TEXT1 lines
1Give every product detail page a distinct Title Tag containing its product name while keeping the in-page H1 intact. Switch between two product pages to verify that the browser tab title updates dynamically.

09 | Page Metadata: Information Written for External Readers

Page Metadata lives inside the HTML document head, is not rendered directly in the visible page body, and exists specifically for browsers, search engines, social platforms, and app install surfaces to read.

Browser tabs read the page title, search engines inspect the meta description, social apps scrape share-card tags, and desktop install prompts read the Manifest configuration.

Together these declarations are called Page Metadata. Each external consumer reads its own fields and must be checked individually—there is no single master toggle that fixes them all.

A working browser tab title does not guarantee that messaging apps or X will show a preview image; a working share card does not guarantee the installed desktop app has the right name and start URL. When debugging, identify which external system is reading the tag first.

Page Metadata consumers and their distinct responsibilitiesPage Metadata consumers and their distinct responsibilities

Diagram Note: A single web page serves different metadata to different consumers: Favicon populates the browser tab, Open Graph builds the share card, and the Manifest controls the installed app's icon and launch behavior. None of them substitute for the others.

Copy-ready instruction for your Agent:

TEXT1 lines
1Audit the Page Metadata this page exposes to browser tabs, search snippets, link sharing, and app installation. List the exact fields used by each consumer and verify the live output for every one of them.

10 | Favicon: The Site Icon in Browser Tabs and Bookmarks

A Favicon is the small icon browsers use to identify your site in tabs, bookmark bars, and browsing history. When a user has dozens of tabs open, they rely primarily on this tiny icon to find their way back to your site.

The Favicon, the navbar brand logo, and UI icons next to buttons are three separate asset configurations.

They can share the same brand mark, but swapping out the logo in your site header will not automatically update the Favicon in the browser tab.

If the browser still shows the old Favicon after an update, stale local cache is usually the culprit. Troubleshooting requires checking the icon file itself, the HTML <link> reference path, and the result in an incognito window or after clearing cache.

Copy-ready instruction for your Agent:

TEXT1 lines
1Replace the site's Favicon without changing the header logo or UI button icons. Check the referenced icon assets and verify them across tabs, bookmarks, and history; if the old icon persists, provide cache evidence.

Open Graph (abbreviated as OG) is a metadata protocol that defines how a web link renders as a preview card when shared.

When you paste a URL into a messaging app or social feed, the title, summary, cover image, and target URL on the preview card come primarily from the page head's og:title, og:description, og:image, and og:url tags.

Just because a cover image renders fine inside the article body does not mean social crawlers can fetch it for a share card.

The og:image URL must be a full public https:// URL directly reachable by external servers. Supplying a local path, an auth-gated URL, or a relative path causes the preview card image to vanish.

Social platforms also cache previously scraped cards. Inspecting the HTML source after a code edit is not enough—test the actual preview using each platform's card validator or a real share test.

Copy-ready prompt for your Agent:

TEXT1 lines
1Add complete Open Graph title, description, absolute image URL, and canonical URL tags for this article. Do not treat a visible in-body cover image as proof—verify the live result with an external share preview test.

12 | Web App Manifest: App Identity and Launch Behavior After Installation

A Web App Manifest is typically a .json configuration file that defines the application name, icons, and launch behavior once a web page is added to a mobile home screen or desktop.

Common fields include name, icons, start_url, and display. Browsers read these fields to decide what name appears at installation, which icon is used, which route opens on launch, and whether it opens in a regular browser tab or a standalone app window.

Manifest icons and the Favicon serve separate roles: the Favicon appears in browser tabs and bookmarks, while Manifest icons represent the installed app on the home screen or desktop—both must be configured separately.

Adding a Manifest only makes a site installable; it does not turn it into a full offline-capable PWA. Offline caching still requires writing a separate Service Worker script.

Copy-ready instruction for your Agent:

TEXT1 lines
1Inspect the Web App Manifest referenced by this page and verify name, icons, start_url, and display. After updating, uninstall the old app, reinstall it, and verify the name, icon, launch URL, and window mode—do not equate installability with offline support.

12-Term Quick Reference & Communication Method

When reading an Agent's status update, use this quick checklist to identify which layer it actually touched:

  • Entire user-visible and interactive interface: Frontend
  • Content structure and semantic tags: HTML
  • Visual styling and responsive layout: CSS
  • Plain text with structural markers for headings, lists, and code: Markdown
  • Reusable UI unit shared across pages: Component
  • Dynamic data and status currently tracked by the UI: State
  • Live node tree in browser memory at runtime: DOM
  • Browser tab title: Title Tag
  • Head metadata read by browsers, search engines, and social apps: Page Metadata
  • Small site icon in tabs and bookmarks: Favicon
  • Social preview card when sharing a link: Open Graph
  • App name, icon, and launch rules when installed to desktop/home screen: Web App Manifest

You do not need to memorize these definitions. Next time an Agent mentions an unfamiliar term, clarify two questions first:

  1. Which part of the page or system is it responsible for?
  2. After the change, where exactly should I see a concrete difference?

Once those two questions are clear, your prompts to the Agent shift from a vague "can you check what's wrong" into precise, verifiable engineering instructions.

VibeCodingFrontend DevelopmentAI CodingWeb TerminologyHTMLCSSPrompt EngineeringProduct Development

Found this actionable? Copy standard citation & summary

Formatted with canonical attribution link and executive summary—ready for Slack, Notion, or LLM context.