Learn Css, Egghead and Vue

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker

**Note:** This course is being actively developed and more lessons will be added in the future.

Cursor is an AI-enhnaced code editor that allows you to call upon the robots to refactor or stub out functions for you with natural language. 

In this course, John will show you workflows that will save you time and effort by utilizing the features such as its mult-line editing and context.

In particular, by giving Cursor's AI the proper context, whether that's lines of code or multiple files, you'll get better output when trying to extend or refactor logic that's present.


Bite-size video tutorials for badass web developers.

egghead

Productive Developer Workflows with AI Enhanced Cursor IDE

Bootstrap is an incredibly popular CSS framework designed to make your website look great on mobile and desktop.

By the end of this course, you'll be familiar with many of the popular classes and components that Bootstrap uses to apply in your own projects.

For each feature you build in the course, you'll get a sense for what the relevant classes do for those components and links to documentation for further exploration.

For the course demo application, we will analyze the landing pages of Microsoft and Apple to identify common components that are implemented. When these are identified, you'll implement these components yourself with Bootstrap.

You'll build several common UI elements such as a nav bar, a carousel of images, Cards, and Forms.

Through building these components, you'll understand what is behind the different classes Bootstrap gives you and get familiar with how it exposes flex and grid layout for you.

Cascading Style Sheets bring order and beauty to our applications.

Create Professional Responsive Websites using Bootstrap

Vue (pronounced /vjuː/, like view) is a progressive framework for building user interfaces. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable. The core library is focused on the view layer only, and is very easy to pick up and integrate with other libraries or existing projects. On the other hand, Vue is also perfectly capable of powering sophisticated Single-Page Applications when used in combination with modern tooling and supporting libraries.

There are several components from the `@tresjs/cientos` that you can use to enhance your **TresJS 3D scenes**.

- `ContactShadows` for performant fake shadows
- Wrap models with `Levioso` for subtle floating animations
- Add real HTML markup to your animations with `HTML`

Using these abstractions from `@tresjs/cientos`, you can create polished **3D experiences**.

Enhance Your TresJS Scenes with the @tresjs/cientos Package

In this **TresJS** lesson you will see how to connect a 3D model to your application state. You'll learn to:

- Access your model's material colors using the `materials` property from `useGLTF`
- Use Vue's `watch` function to update the model's colors when the user changes the selection in the UI

This allows you to create an interactive 3D experience that responds to user input.

Connect a TresJS Model with Vue State

In this lesson, you'll learn how to create a reactive color selector in Vue using the `useState` composable function. We'll cover:

- Creating a shared state that contains base colors and a selected base color
- Using the `toRefs` utility to convert reactive properties to refs
- Importing and using the `useState` composable in components
- Iterating through colors to create buttons
- Assigning click event handlers to update the selected color reactively

Create a Reactive Color Selector in Vue with useState

In this **TresJS** tutorial, we'll explore how to find and use free 3D models in GLTF format from sites like:

- [poly.pizza](https://poly.pizza/)
- [Sketchfab](https://sketchfab.com/)
- [pmndrs Market](https://market.pmnd.rs/)

We'll then cover using the `useGLTF` composable from `drei-sfc` to load models asynchronously, handling it gracefully with Vue's `<Suspense>` component. 

Once loaded, you will see how to explore the object and get the model node you're looking for. Then, you'll pass that node to the Vue `primitive` component's `:object` prop to render the model. 

By the end of the lesson, you'll be ready to start adding awesome 3D models to your own TresJS projects!

Load Models with useGLTF and the TresJS primitive Component

This is an overview of the [TresJS project template](https://github.com/alvarosabu/egghead-tres-3D-product-configurator/tree/main/lessons/starter).

The template is styled with the atomic CSS framework, [UnoCSS](https://unocss.dev), and comes with a default TresJS scene setup, including:

- a perspective camera
- ambient light
- directional light

There is also a color selector initially implemented using an array of colors and a `ref` variable for the selected color. Each color is rendered as a circle. 

Project Overview of the TresJS Product Template

In this **TresJS** lesson you will learn how to use `OrbitControls` from the [@tresjs/cientos](https://cientos.tresjs.org/) package to add interactivity to your scenes by:

- Importing `OrbitControls`
- Adding it below your `TresPerspectiveCamera` component

The `@tresjs/cientos` package is part of the TresJS ecosystem and provides useful abstractions and composables to extend the core framework. 


Use OrbitControls to Interact with your TresJS Scene

In this **TresJS** lesson, we explore how to animate 3D objects in a scene using the render loop. 

We'll cover:

- Using the `useRenderLoop` composable and `onLoop` callback to run code every frame
- Creating refs with `useRef` to reference and modify 3D object properties like position and rotation
- Handling varying device frame rates with `delta` or `elapsed` time for consistent animation speed

By the end of the video, you'll be ready to create smooth animations in your own TresJS scenes.

Animate TresJS Objects with the useRenderLoop Composable

In this **TresJS** lesson, you'll learn how to **enable shadows** in your 3D scenes. 

We'll cover: 
- the `shadows` prop to turn on shadows
- the `cast-shadow` property for lights
- and the `cast-shadow` and `receive-shadow` properties for meshes. 

You will see how to adjust light intensity, position, and object placement to **control the appearance of shadows**. By the end, you'll understand the key aspects of configuring shadows in TresJS scenes.

Enable Shadows in Your TresJS Scene

This TresJS lesson teaches you the basics of lighting 3D scenes. 

You'll learn how to:

- add ambient lights for overall lighting `<TresAmbientLight />`
- add directional lights for light from a specific direction `<TresDirectionalLight />`
- change light color and intensity using theprops. 

You will also see how materials, such as the `<TresMeshStandardMaterial>`, work with the lights in your scene.

Add Ambient and Directional Lighting to Your TresJS Scene

This TresJS lesson shows you how to transform 3D objects in your scene. You'll learn how to:

*   Adjust an object's position with `TresMesh`'s `position`, `scale`, and `rotation` props   
*   Use the `TresAxesHelper` component to guide object transformations in 3D space
    

Transform TresJS Objects Using Props

Learn how to add a 3D cube to your TresJS scene using the `TresMeshComponent`, `TresBoxGeometry`, and `TresMeshNormalMaterial` components. 

This lesson shows TresJS's declarative approach that makes 3D rendering simpler than using plain Three.js.

Add a Cube to Your TresJS 3D Scene

[TresCanvas](https://docs.tresjs.org/api/tres-canvas) is a Vue.js component that wraps the Three.js renderer. 

It can be imported, added to templates, and customized with props like background color and window size.

Add a TresCanvas to Your Vue App

[Link to the course repo](https://github.com/alvarosabu/egghead-tres-3D-product-configurator)

Our goal is to create an application that allows the user to customize a 3D product with different color materials visually. The first step is setting up the starter to follow up during the course

In this first lesson, we will download the course repo ‣. The repo is a monorepo containing all the lessons available for this course. When you clone it you are going to find

Getting Started with the TresJS Product Course Repo

Create Interactive 3D Experiences with TresJS

Now that we have a project, we need a Pin input to work with. We'll create 4 inputs and style them so they look like a security code pin input that you would expect to see.

Style a Pin Input through Data Attributes in React

Some components render differently based on the route they are rendered on. To use router within component tests, it is best to define its default values in `cy.mount()` function. Since we can customize this in any way we’d like, we can create a custom `path` attribute where we can pass our own routes and test our component behavior against them.

Test a Component Rendering Within Different Router Locations in Cypress Component Test

Every component test that uses Pinia needs to have Pinia imported and initialized. Instead of doing this separately for each test you can customize your `cy.mount()` command to automatically use a default store. You can further then customize it to use your own store in case you want to change its state.

Rewrite Cypress mount() Command to Provide a Default Store to all Components

Instead of calling an action function to change the state, we can choose to change it directly by importing the attributes from our store. In order to not loose reactivity while destructuring properties we can use `storeToRefs()` function.

Mutate Application State Properties Directly with Pinia’s storeToRefs()

I'm extremely excited for the potential of AI watching your screen while you work. I decided to take Google's AI Studio for a spin, which just introduced a feature called "Stream Realtime", which allows AI Studio to observe your screen and listen to your microphone while you work.

This video is my initial attempt to try and coach AI Studio through the process of building a site from a reference site, essentially trying to build egghead.io from a Next.js starter template. And we'll explore the various attempts we make and what works and what doesn't.

Let AI Watch Your Screen: Build Next.js Pages with AIStudio's Stream Realtime


[Shadcn](https://ui.shadcn.com/docs) is a popular component library that allows you to install components into your codebase.

Learn how to install the [Table component](https://ui.shadcn.com/docs/components/table) and use that presentational component with [Tanstack table](https://tanstack.com/table/latest).


Display Tabular Data in React with Tanstack Table

Build a dynamic table component in React using shadcn component library and tanstack react table.

TypeScript's satisfies operator finally clicked for me when I realized it's almost always used for specific implementations of configuration objects. So this lesson walks you through the naive approaches I've taken before and how to solve them using the satisfies operator. After this, satisfies will be another tool in your belt in TypeScript. To clean up all the TypeScript code you have around configuration.

TypeScript's "satisfies" for Configuration

Windsurf and Cursor are both able to take an image and then use an agent to build out what it sees in that image. This lesson is going to compare Windsurf and Cursor by uploading the same image to both and giving them the same prompt. Comparing not only the results, but also the steps that they take to get there. We'll also try uploading additional images throughout the process to see what they do as far as revising along the way and improving the site as they go along. 

Windsurf Cascade vs. Cursor Composer Agent: Build a Site from an Image

In this lesson, you'll discover how to style View Transitions using CSS pseudo-selectors to create custom animation effects. We'll transform the default cross-fade into a smooth slide transition by targeting the ::view-transition-old and ::view-transition-new pseudo-elements. You'll learn how these powerful selectors give you precise control over your transition animations, allowing you to create more engaging and personalized user experiences with just a few lines of CSS.

Customize View Transitions with CSS Using view-transition-old and view-transition-new

In this lesson, you'll learn how to implement smooth state transitions in your web applications using the browser's built-in View Transitions API. We'll create a simple example that demonstrates how to animate between different text states with just a few lines of code - no external libraries required. This powerful native API makes it easy to add professional-looking transitions to your user interface, enhancing the user experience with minimal effort.

Create Smooth UI Transitions with the Native View Transitions API

I've been using Cursor for a very long time and their "Agent" feature in Composer is fairly new, so I'm still getting used to it. But since Windsurf recently got onto the stage with their Cascade agent, they've slowly been gaining the mind share on the UX for coding agents. I decided to put them to the test by putting Windsurf and Cursor on the exact same screen side by side trying to accomplish the same task and to see which workflow I would prefer. I've been a diehard Cursor user for over a year now, so it's going to take a lot for me to switch to a different IDE. But I just have to say, even from this simple demo, Windsurf is looking pretty nice.

This lesson is just going to walk through creating a CLI using both tools to print out inspirational quotes and to explore how they approach the step-by-step of installing packages and running commands and setting up all the files we need to get this running.

Windsurf Cascade vs. Cursor Composer Agent Side-by-Side Comparison

I've been using Cursor as my primary editor for over a year now, but recently I've heard wonderful things about Windsurf AI Agent features. I decided to record myself building out something I've always wanted to make, but never made the time for.

In this lesson, I demonstrate how to leverage Windsurf's powerful agent process to create a fun word-guessing game inspired by Heads Up. Watch as I build an interactive application featuring category selection and word navigation, complete with data hosting on GitHub Gists and deployment to GitHub Pages - all in under 30 minutes (before editing the lesson down to 12 minutes)!

What makes this project particularly exciting is how Windsurf eliminates the typical friction points of development. While this game was always on my project wishlist, the overhead of setup, configuration, and deployment made it hard to justify the time investment. Windsurf's agent process handles all these pain points seamlessly, from managing URLs to orchestrating deployment.

This lesson perfectly showcases how AI agents can help developers bring their backlog of project ideas to life, transforming what would typically be time-consuming tasks into efficient, enjoyable development experiences.

Build a Word Game with Windsurf's Cascade AI Agent



Discover how to harness the power of Cursor IDE's Composer Agent feature to optimize your code. In this lesson, you'll witness an AI agent doing all the work to generate test suites, implement performance benchmarks, and create optimized function variations - all without writing a single line of code. You'll learn how to validate performance improvements through data-driven benchmarking, ensuring that optimizations are backed by concrete metrics rather than speculation. This hands-on demonstration showcases a groundbreaking approach to automated function development that combines the precision of test-driven development with the efficiency of AI-powered optimization.


Agent-Driven Development in Cursor: Testing, Benchmarking, and Optimizing Functions

This course is aimed for using `zod` effectively in projects based on TypeScript (both browser and node.js). The benefits you gain with this course is not just simply coding, but also understanding when/why/how should you perform runtime validation.

`zod` is the missing piece to TypeScript's capabilities, which can guarantee type-safety only in compile-time.

`zod` can be used whenever the compiler cannot guarantee what happens in runtime. And... it's a very frequent usecase, such as HTTP calls, websockets, etc.

In this course you get quickly up and running by:
1. using `zod` with primitives and objects
2. adapting `zod` quickly to existing projects thanks to automatic generators
3. changing the strategy frm type-first to schema-first
4. using error-throwing `parse` or non-error-throwing `safeParse` basing on your needs
5. applying `zod` to the most common usecase - validating API responses
6. handling errors the most convenient way (out of many!)

Take advantage of runtime validation with `zod`. Take advantage of the detailed lessons in this course 🔥

Search

Search Results