Courses for Front-End Web Developers

AI coding assistants (like Cursor's Composer) are powerful, but running a single instance can become a bottleneck, especially for larger tasks or when experimenting with different approaches.  This lesson shows you how to break free from that limitation by leveraging Git worktrees to enable *parallel* AI development.

**The Problem:**

*   Single Composer instances can be slow for complex tasks.
*   Multiple agents modifying the same files simultaneously lead to conflicts.
*   Traditional branching can be cumbersome for rapid experimentation.

**The Solution: Git Worktrees**

Git worktrees allow you to create multiple, *independent* working directories linked to the *same* Git repository. Each worktree can be associated with a different branch, providing isolated environments for development.

**Workflow:**

1.  **Create Worktrees:** Use `git worktree add -b <branch-name> ../<project-name>-<branch-name>` to create a new worktree and associated branch.  The `-b` flag creates the branch. The path (`../<project-name>-<branch-name>`) places the worktree in a sibling directory (cleaner organization). Repeat for each variation you want to explore.
2.  **Launch Multiple Cursor Instances:** Open Cursor in each worktree directory (e.g., `cursor ../my-project-variant1`). Each instance is now isolated and can work on its assigned branch.
3.  **Assign Tasks to Composer:**  Within each Cursor instance, use Composer (Chat or Agent mode) to work on specific tasks or implement different approaches to the same problem. Use `@` to provide context (files, directories, docs).
4.  **Monitor and Iterate:** Check in on each Composer instance's progress. Because they're in separate worktrees, there are no conflicts.
5.  **Merge the Best Solution:**  Once a branch has a successful solution, merge it back into your main branch using `git merge <branch-name>`.
6.  **Clean Up:** Remove the worktrees with `git worktree remove ../<project-name>-<branch-name>`.

**ZSH Functions (Optional but Powerful):**

The lesson introduces two ZSH functions (provided as code snippets) to automate this process:

*   `wtree()`:  Takes branch names as arguments, creates corresponding worktrees, installs dependencies (with `-p` flag for PNPM), and optionally launches Cursor in each.  This streamlines setup.
*   `wtmerge()`:  Takes a single branch name as an argument, merges that branch into `main`, and then *cleans up all* worktrees created by `wtree()`. This simplifies merging and cleanup.

**Benefits:**

*   **Parallel Development:**  Run multiple Composer instances simultaneously, drastically speeding up development.
*   **Conflict-Free Experimentation:**  Isolate different approaches in separate branches/worktrees, eliminating merge conflicts.
*   **Rapid Iteration:**  Quickly create, test, and merge (or discard) variations of your code.
*   **Clean Workspace:**  Worktrees keep your main project directory uncluttered.

This lesson empowers you to unlock the full potential of AI coding assistants by running them in parallel, fostering faster experimentation and more efficient development. You'll learn a practical technique that significantly boosts your productivity when working with AI-generated code.

```bash
# wtree: Create a new worktree for each given branch.
# Usage: wtree [ -p|--pnpm ] branch1 branch2 ...
#
# This function does the following:
#   1. Parses command-line arguments; if -p/--pnpm is provided, it will later run "pnpm install".
#   2. Determines the current branch and repository root.
#   3. Uses a fixed parent directory (~/dev) to house all worktree directories.
#   4. For each branch passed:
#        - If the branch does not exist, it is created from the current branch.
#        - It checks that a worktree for that branch does not already exist.
#        - It then creates a worktree in ~/dev using a naming convention: <repoName>-<branch>.
#        - If the install-deps flag is true, it runs "pnpm install" inside the new worktree.
#        - Finally, it either opens the new worktree via the custom "cursor" command (if defined)
#          or prints its path.
wtree() {
  # Flag to determine whether to run "pnpm install"
  local install_deps=false
  local branches=()

  # Parse command-line arguments
  while [[ $# -gt 0 ]]; do
    case "$1" in
      -p|--pnpm)
        install_deps=true
        shift
        ;;
      *)
        branches+=("$1")
        shift
        ;;
    esac
  done

  # Ensure at least one branch name is provided.
  if [[ ${#branches[@]} -eq 0 ]]; then
    echo "Usage: wtree [ -p|--pnpm ] branch1 branch2 ..."
    return 1
  fi

  # Determine the current branch; exit if not in a git repository.
  local current_branch
  current_branch=$(git rev-parse --abbrev-ref HEAD) || {
    echo "Error: Not a git repository."
    return 1
  }

  # Determine repository root and name.
  local repo_root repo_name
  repo_root=$(git rev-parse --show-toplevel) || {
    echo "Error: Cannot determine repository root."
    return 1
  }
  repo_name=$(basename "$repo_root")

  # Set fixed parent directory for worktrees.
  local worktree_parent="$HOME/dev"
  # Ensure the worktree parent directory exists.
  if [[ ! -d "$worktree_parent" ]]; then
    if ! mkdir -p "$worktree_parent"; then
      echo "Error: Failed to create worktree parent directory: $worktree_parent"
      return 1
    fi
  fi

  # Loop over each branch provided as argument.
  for branch in "${branches[@]}"; do
    # Define the target path using a naming convention: <repoName>-<branch>
    local target_path="$worktree_parent/${repo_name}-${branch}"
    
    echo "Processing branch: ${branch}"

    # Check if a worktree already exists at the target path.
    if git worktree list | grep -q "^${target_path}[[:space:]]"; then
      echo "Error: Worktree already exists at ${target_path}. Skipping branch '${branch}'."
      continue
    fi

    # If the branch does not exist, create it from the current branch.
    if ! git show-ref --verify --quiet "refs/heads/${branch}"; then
      echo "Branch '${branch}' does not exist. Creating it from '${current_branch}'..."
      if ! git branch "${branch}"; then
        echo "Error: Failed to create branch '${branch}'. Skipping."
        continue
      fi
    fi

    # Create the new worktree for the branch.
    echo "Creating worktree for branch '${branch}' at ${target_path}..."
    if ! git worktree add "$target_path" "${branch}"; then
      echo "Error: Failed to create worktree for branch '${branch}'. Skipping."
      continue
    fi

    # If the install flag is set, run "pnpm install" in the new worktree.
    if $install_deps; then
      echo "Installing dependencies in worktree for branch '${branch}'..."
      if ! ( cd "$target_path" && pnpm install ); then
        echo "Warning: Failed to install dependencies in '${target_path}'."
      fi
    fi

    # Optionally, open the worktree directory via a custom "cursor" command if available.
    if type cursor >/dev/null 2>&1; then
      cursor "$target_path"
    else
      echo "Worktree created at: ${target_path}"
    fi

    echo "Worktree for branch '${branch}' created successfully."
    echo "-----------------------------------------------------"
  done
}


# wtmerge: Merge changes from a specified worktree branch into main,
# then clean up all worktrees and delete their branches.
#
# Usage: wtmerge <branch-to-keep>
#
# This function does the following:
#   1. Verifies that the branch to merge (branch-to-keep) exists as an active worktree.
#   2. Checks for uncommitted changes in that worktree:
#        - If changes exist, it attempts to stage and commit them.
#        - It gracefully handles the situation where there are no changes.
#   3. Switches the current (main) worktree to the "main" branch.
#   4. Merges the specified branch into main, with proper error checking.
#   5. Uses "git worktree list" to retrieve all active worktrees (under ~/dev
#      and matching the naming pattern) and removes them.
#   6. Deletes each branch that was created for a worktree (skipping "main").
wtmerge() {
  # Ensure exactly one argument is passed: the branch to merge.
  if [ $# -ne 1 ]; then
    echo "Usage: wtmerge <branch-to-keep>"
    return 1
  fi

  local branch_to_keep="$1"

  # Determine the repository root and its name.
  local repo_root repo_name
  repo_root=$(git rev-parse --show-toplevel) || {
    echo "Error: Not a git repository."
    return 1
  }
  repo_name=$(basename "$repo_root")

  # Fixed parent directory where worktrees are located.
  local worktree_parent="$HOME/dev"

  # Retrieve all active worktrees (from git worktree list) that match our naming convention.
  local worktrees=()
  while IFS= read -r line; do
    # Extract the worktree path (first field)
    local wt_path
    wt_path=$(echo "$line" | awk '{print $1}')
    # Only consider worktrees under our fixed parent directory that match "<repo_name>-*"
    if [[ "$wt_path" == "$worktree_parent/${repo_name}-"* ]]; then
      worktrees+=("$wt_path")
    fi
  done < <(git worktree list)

  # Check that the target branch worktree exists.
  local target_worktree=""
  for wt in "${worktrees[@]}"; do
    if [[ "$wt" == "$worktree_parent/${repo_name}-${branch_to_keep}" ]]; then
      target_worktree="$wt"
      break
    fi
  done

  if [[ -z "$target_worktree" ]]; then
    echo "Error: No active worktree found for branch '${branch_to_keep}' under ${worktree_parent}."
    return 1
  fi

  # Step 1: In the target worktree, check for uncommitted changes.
  echo "Checking for uncommitted changes in worktree for branch '${branch_to_keep}'..."
  if ! ( cd "$target_worktree" && git diff --quiet && git diff --cached --quiet ); then
    echo "Changes detected in branch '${branch_to_keep}'. Attempting auto-commit..."
    if ! ( cd "$target_worktree" &&
            git add . &&
            git commit -m "chore: auto-commit changes in '${branch_to_keep}' before merge" ); then
      echo "Error: Auto-commit failed in branch '${branch_to_keep}'. Aborting merge."
      return 1
    else
      echo "Auto-commit successful in branch '${branch_to_keep}'."
    fi
  else
    echo "No uncommitted changes found in branch '${branch_to_keep}'."
  fi

  # Step 2: Switch to the main worktree (assumed to be the current directory) and check out main.
  echo "Switching to 'main' branch in the main worktree..."
  if ! git checkout main; then
    echo "Error: Failed to switch to 'main' branch."
    return 1
  fi

  # Step 3: Merge the target branch into main.
  echo "Merging branch '${branch_to_keep}' into 'main'..."
  if ! git merge "${branch_to_keep}" -m "feat: merge changes from '${branch_to_keep}'"; then
    echo "Error: Merge failed. Please resolve conflicts and try again."
    return 1
  fi

  # Step 4: Remove all worktrees that were created via wtree().
  echo "Cleaning up worktrees and deleting temporary branches..."
  for wt in "${worktrees[@]}"; do
    # Extract branch name from worktree path.
    local wt_branch
    wt_branch=$(basename "$wt")
    wt_branch=${wt_branch#${repo_name}-}  # Remove the repo name prefix

    echo "Processing worktree for branch '${wt_branch}' at ${wt}..."
    # Remove the worktree using --force to ensure removal.
    if git worktree remove "$wt" --force; then
      echo "Worktree at ${wt} removed."
    else
      echo "Warning: Failed to remove worktree at ${wt}."
    fi

    # Do not delete the 'main' branch.
    if [[ "$wt_branch" != "main" ]]; then
      if git branch -D "$wt_branch"; then
        echo "Branch '${wt_branch}' deleted."
      else
        echo "Warning: Failed to delete branch '${wt_branch}'."
      fi
    fi
  done

  echo "Merge complete: Branch '${branch_to_keep}' merged into 'main', and all worktrees cleaned up."
}
```


John Lindquist

Launch Multiple Cursor Composer AI Agents to Work in Parallel

AI-generated code often comes riddled with errors, especially TypeScript errors.  Trying to fix these *one by one* with in-editor AI tools (like Cursor's "Fix with AI") can be slow, frustrating, and sometimes even *introduce* new problems.  The fixes can be too localized, missing the bigger picture.

This lesson demonstrates a more efficient workflow: leveraging the power of **reasoning models** (like those found in AI Studio or advanced ChatGPT models) to fix errors *in bulk*.

Here's the process:

1.  **Identify All Errors:** Use the "Problems" panel in your editor to get a comprehensive list of all errors in the file.  Don't try to fix them individually yet! (Use `Cmd/Ctrl + Shift + P`, then type "problems".)
2.  **Gather Context:**
    *   Copy the *entire file's code*.
    *   Copy the *entire list of errors* from the Problems panel.
3.  **Prompt the Reasoning Model:** Paste *both* the code and the error list into a reasoning model.  Your prompt should be something like:  "Please fix all of these errors and rewrite the entire file with the corrections."  The key is to give the AI the *full context*. Wrap your code with XML tags to help the AI recognize it.
4.  **Iterate (if needed):**  Copy the corrected code back into your editor.  If a few errors remain, *now* it's time to use in-editor AI tools (like Cursor's Composer or "Fix with AI") for the final cleanup. These tools are better suited for small, isolated issues.
5.  **Provide Additional Context (for Stubborn Errors):** If a specific error persists (e.g., related to a library like `yargs`), provide *even more* context to the AI:
    *   Include links to the library's documentation (NPM page, official docs).
    *   Use Cursor's `@` feature to add specific files or documentation to the context.
6. Make sure to test! Run `npm test` or whichever testing command you're using for this project.

**Why this works:**

*   **Holistic Understanding:** Reasoning models excel at understanding the *relationships* between different parts of the code. They can see how a change in one place affects others, leading to more consistent and correct fixes.
*   **Efficiency:** Fixing multiple errors in a single pass is *much* faster than addressing them individually.
*   **Reduced "Whack-a-Mole":**  Fixing one error often reveals another.  Bulk fixing with a reasoning model minimizes this frustrating cycle.

This lesson teaches you a practical, powerful technique to tame AI-generated code and get it working quickly, even when it arrives full of errors. By combining the strengths of reasoning models and in-editor AI, you'll become a more efficient and confident developer.


Bulk Fixing AI-Generated Code Errors with Reasoning Models and Cursor Composer

In this lesson, we learn that counting documents that meet certain criteria in MongoDB can be done with the countDocuments() method.

We demonstrate how to retrieve the total number of documents when no query is specified and how to filter results using regular expressions.

For example, we can count employees with names containing a lowercase "a" or those with specific skills, using `$regex`.

Additionally, we show how to count documents where age is not equal to a given value, illustrating the versatility of the `countDocuments()` method in various scenarios.


Tomasz Ducin

Count documents satisfying a query in MongoDB Collection (countDocuments, $regex, $in)

Count documents in MongoDB collections using countDocuments() with query filters, including regex and specific conditions, using $regex, $in

In this lesson, we learn that we can perform advanced filtering in MongoDB by using expressions within our queries. All thanks to `$expr`.

We demonstrate how to compare multiple document properties, such as ensuring age is less than salary using comparison operators (`$lt`, `$lte`, `$gt`, `$in`, `$nin`, etc).

Additionally, we explore filtering based on the length of an array (`$size`) to check for specific skills.


Filtering Documents using Expressions in MongoDB Collections ($expr, $size, $in, $and, etc)

Filter MongoDB documents using expressions $expr with comparison operators $lt, $gt, $eq and array length checks $size

In this lesson, we learn that combining multiple criteria in MongoDB queries can be done using logical operators such as `$and` and `$or`.

We demonstrate how to create queries that filter documents based on various conditions, such as _age_ and _skills_.

Additionally, we explore the use of the `$in` operator for matching any values in an array and the `$all` operator for ensuring all specified values are present.

This lesson provides essential skills for effective use of operators such as: `$in`, `$nin`, `$lt`, `$lte`, `$gt`, `$gte`, `$eq`, `$ne` (and many others) in querying MongoDB collections.



Combine Filtering Documents in MongoDB Collections ($and, $or, $in, $eq, etc)

Combine filtering criteria in MongoDB with logical operators like $and, $or; use $in and $all for array filtering in this lesson on document queries.

In this lesson, we learn that filtering documents from MongoDB collections can be achieved through the `find` and `findOne` methods.

We demonstrate how to use these methods to retrieve documents based on specific criteria, such as names or emails, and how to apply regular expressions for more general searches.

Additionally, we explore filtering by array values and using conditions like less than or greater than for numerical properties.


Filtering Documents in MongoDB Collections (find, findOne)

Learn to filter MongoDB documents using find and findOne methods with query criteria, regex, and array filtering in this lesson on document retrieval.

In this lesson, we learn that inserting documents into a MongoDB collection can be done using the `insertOne` and `insertMany` methods.

We demonstrate how to create new employee objects in JSON format and add them to a collection.

We also show how to view the inserted documents and their automatically generated IDs.

Furthermore, we discuss how to delete documents from a collection using filtering criteria.


Inserting Documents into MongoDB Collections (insertOne, insertMany)

Insert documents into MongoDB collections using the Mongo shell mongosh and MongoDB Compass, using the insertOne and insertMany methods

In this lesson, we learn that creating a MongoDB collection can be done easily through MongoDB Compass or the Mongo shell: `mongosh`.

We cover how to use the GUI to add a new collection and understand that there’s no need for a predefined schema, allowing us to store documents with varying structures.

We also discuss how to remove a collection when it’s no longer needed, demonstrating both methods for flexibility in managing our database.

We also see `find`, `countDocuments` and `drop` MongoDB collection methods in action!


Create or Remove MongoDB Collection

Learn to create and remove MongoDB collections using MongoDB Compass and the Mongo shell in this practical lesson on collection management.

In this lesson, we learn that MongoDB Compass is a graphical user interface for managing MongoDB databases.

We cover how to download and install Compass, create a connection to our local MongoDB instance, and troubleshoot any connection errors.

Additionally, we explore how to navigate the interface to view collections and documents easily.

This lesson provides a practical understanding of using Compass for MongoDB database management.



Access Mongo databases from MongoDB Compass

Learn to access MongoDB databases with MongoDB Compass. Install, connect, and explore data visually, locally and free.

In this lesson, we learn that when querying MongoDB collections, we can control which properties are returned by using projections with the `findOne` method.

We demonstrate how to include or exclude fields by setting them to 1 or 0, respectively. For example, we can choose to include the name and position while excluding the `_id` field.

We also cover how to access nested properties and project specific elements from arrays using the `$slice` operator, allowing for more precise data retrieval based on our needs.

Return a subset of properties of a MongoDB Document (projections, $slice)

Return specific properties from MongoDB documents using projections in the findOne method, including nested fields and array slicing, $slice

In this lesson, we learn that searching for a MongoDB document by its ID can be a little tricky in the beginning.

We demonstrate how to use the `_id` field to search for specific documents and emphasize the necessity of wrapping the ID with the `ObjectId` constructor. This step is crucial because failing to do so can result in empty results, underscoring the importance of proper syntax when querying by document ID.


Find Document by id in MongoDB Collections

Find MongoDB documents by their unique _id using the ObjectId constructor without mistakes.

You will learn how to create and manage complex, nested schemas using a real world example (room bookings with guest details) used throughout all lessons. All created schemas are tested against potential bugs and we verify error messages.

The course covers topics such as:

- Utilizing Zod's shape and unwrap features to perform partial validations without losing the overall schema structure.
- Managing optional, nullable and nullish properties.
- Implementing unions and intersections to handle different types of data.
- Ensuring type safety with sets and maps, including custom validation logic for primitive values.
- Creating custom error messages for improved user feedback.

Get a solid understanding of how to leverage Zod to enhance runtime data validation in JavaScript/TypeScript applications 🔥

Advanced Type Checks with Zod

Get a solid understanding of how to leverage Zod to enhance runtime data validation in JavaScript or TypeScript applications

Get started with MongoDB and Docker really quick 🔥 even if you have no backend/fullstack experience.

This lesson guides you through installing Docker Desktop and setting up a MongoDB image.

We explain Docker images and containers, and their roles in providing isolated software environments.

We run a MongoDB image in 2 ways: using the terminal and Docker Desktop

We demonstrates configuring port settings for a container and accessing the MongoDB shell (`mongosh`) to interact with the database.

We learn how to manage Docker containers, configure settings, and run commands inside the container.

Grab the CLI command: 🔥 `docker run --name some-mongo -d mongo:latest` 🔥

Install Docker to run local MongoDB Container

Learn to install Docker Desktop, set up a MongoDB image, and manage containers. Configure ports and access the Mongo shell

[https://github.com/johnlindquist/mcp-cursor-tool-starter/tree/main](https://github.com/johnlindquist/mcp-cursor-tool-starter/tree/main)

Cursor's AI is powerful, but it can't do everything. What if you could give it the ability to interact with your specific workflows, tools, and data? This lesson shows you how to do exactly that by building a custom MCP tool – and we'll do it in under two minutes!

We'll leverage the Model Context Protocol (MCP), an open standard that bridges the gap between AI agents (like Cursor's Composer) and your custom code. By creating an MCP tool, you're essentially giving Cursor a new skill.

Here's the breakdown:

Understanding MCP: We'll briefly cover what the Model Context Protocol (MCP) is and why it's the key to extending Cursor's functionality. In short, it enables communication between the AI and your tools in a standardized way.

Fast Track Setup: We'll use a ready-made starter project (a single TypeScript file and package.json) to skip the boilerplate and get straight to the core concepts.

Step-by-Step Integration: We'll walk through the simple process of:

Cloning the starter project.

Installing dependencies with pnpm install.

Running the starter server.

Adding the tool to Cursor's MCP settings (under Features > MCP).

Verifying that your tool is working

Real-World Example: We'll demonstrate the tool in action, using Cursor's Composer to create a new GitHub issue using the gh CLI, all driven by our custom MCP tool.

This lesson is about more than just building one tool; it's about understanding how to extend Cursor's capabilities to fit your unique development needs. You'll learn the foundational steps to create a whole ecosystem of AI-powered tools.

Build Your First MCP Tool in Cursor in Just 2 Minutes

Displaying data in tables has been notoriously hard to implement. Naive implementations of data tables will leave your app slow and janky and many table libraries out there are restricted to a few select UI frameworks they use or aren't very customizable.

Tanstack Table is a 'headless' option meaning you have complete control of the presentation while taking advantage of the data side of the equation.

You'll be able to fetch and display remote data, handle pagination, and implement row virtualization for better performance.

Once you've implemented basic functionality you can take your tables to the next level customizing cells with your own JSX components, adding features like toggling column visibility, and ensuring your table is mobile-friendly with CSS pseudo-elements.

By the end, you'll have the skills to create efficient, user-friendly tables that elevate your applications. You can take what you learn here (using React) to any of the popular modern UI frameworks that fit your project requirements.

Ian Jones

Headless, Mobile-friendly Data Tables with Tanstack Table and React

Learn to display, paginate, and virtualize data effectively in a table with Tanstack table and React 19.

Install `ghx` with `npm i -g @johnlindquist/ghx`

https://github.com/johnlindquist/ghx

You've copied and pasted code, set up your project, and... *error*.  "Stream is not readable."  Sound familiar?  Generic Google searches and outdated Stack Overflow answers often leave you more confused than when you started.  You need more than just documentation; you need *context*.  You need to see how real developers solve this *exact* problem.

This lesson shows you a better way to debug, using real-world GitHub examples and the power of Cursor's Composer.

Here's the workflow we'll cover:

1.  **Identify the Error:** You've already done this!  You have a specific error message ("Stream is not readable") and the code that's causing it.
2.  **Find Real-World Solutions with `ghx`:** We'll use `ghx`, a tool for searching GitHub, to find *actual projects* that have encountered (and solved!) this same issue.  No more generic advice – you'll see working code.
3.  **Consolidate and Analyze:**  `ghx` brings those relevant code snippets into a single, easy-to-read file.
4.  **Leverage Cursor's Composer:** We'll use Cursor's Composer to directly interact with the examples and your problematic code.  Paste in your error, reference the `ghx`-generated file, and ask targeted questions like:
    *   "Based on these examples, how should I modify my code to fix the 'stream is not readable' error?"
    *   "What's the common cause of this error in the context of an MCP server?"
    *   "Show me the specific lines in the examples that handle stream readability correctly."
5. **Fix the Error:** Implement the solution using this workflow.

Instead of guessing, you'll learn directly from proven solutions.  You'll gain a deeper understanding of your issue and how to troubleshoot it effectively.  This approach transforms debugging from a frustrating hunt into a targeted learning experience.

Fix Real-World Coding Errors with GitHub Context through ghx and Cursor Composer

Learn how to test custom ESLint rules with Vitest and RuleTester.

In the [previous video](https://egghead.io/set-up-a-custom-es-lint-rule~kq49h), we created a custom eslint rule that gives us a warning when some of the class names don’t start with a lowercase letter.

Here, I'll show you how to test this or any other custom ESLint rule using unit tests without manually restarting the ESLint server or modifying production code to check if the rules work correctly. We'll look at the structure in which correct and incorrect code samples should be specific to RuleTester.

We'll also learn how to make our rule fixable and verify that the applied fix works as expected.

Test Custom ESLint Rules with Vitest and RuleTester

Learn to test a Custom ESLint Rule using Vitest and RuleTester.

AI is amazing for generating code, but often leaves us staring at functions and libraries we've never seen before. This creates a huge problem: When things break (and they will break), we're lost. We don't understand the individual pieces, let alone how they interact. Knowing one part isn't enough; we need to see how unfamiliar components work together.

The solution? Real-world examples.

This lesson introduces ghx, a tool I built to do exactly that. ghx searches GitHub, finding actual code examples that use the specific combinations of functions and libraries that are tripping you up. Instead of generic documentation, you get concrete implementations. You can find the ghx repository at https://github.com/johnlindquist/ghx.

Here's the workflow we cover:

Identify the Unknown: Pinpoint the AI-generated code you don't understand – specific functions, libraries, or their interactions.

Search with ghx: Use ghx to search GitHub for examples using those terms together. ghx finds repos where those elements co-exist.

Consolidate Examples: ghx combines the relevant code snippets from those examples into a single, digestible file.

Ask the AI (Again, but Better!): Feed this consolidated code to an AI (like a coding-focused model in an AI studio). Now, instead of asking general questions, you can ask targeted questions based on real-world usage:

"Explain how these functions are used together in these examples."

"What are some common use cases for this combination of libraries?"

"Show me alternative code snippets that achieve the same result."

"Can you identify potential problems or areas for improvement, based on these examples?"

Iterate. Use your improved understanding to make changes, and then repeat the process to debug.

By leveraging ghx and targeted AI prompting, we transform from being lost in a sea of unfamiliar code to actively learning from how others have solved similar problems. We gain a deeper understanding of our AI-generated codebase, making debugging, modification, and future development far more manageable. This gives you the tools to understand, debug and improve your own code.

How to Work with AI-Generated Code You Don't Understand with ghx and Gemini

In this less we create a custom Zod schema using `z.custom`.

The example case covers room numbers validation: it must start with an uppercase letter followed by three digits. `z.custom` allows the creation of a brand new custom schema with a callback function that returns a boolean indicating validity.

We highlight a challenge with type inference in Zod's custom schemas: callback parameter types don't get aligned automatically - type-safety must be explicitly defined using type parameters.

We run tests against various room numbers and demonstrate how to effectively validate inputs and manage error messages.


Create Custom Zod Schemas and Validate project-specific data

Create custom validation logic in Zod using z.custom, for primitive values, ensuring type safety and proper error messages for room numbers.


In this lesson we make use of partial validation of large and nested schemas in Zod.

Instead of creating many small schemas, which can complicate maintenance, Zod allows for the extraction of specific parts of a schema using the concept of ".shape". It "unwraps" the object schema, enabling access to sub-schemas within specific properties.

Additionally, we can use the `.unwrap` to get into element schemas of altered schemas such as `.optional` or `.array`.

Simplify working with complex schemas without the need to break them into hundreds of small schemas.

Use Zod Schemas partially using shape and unwrap

Manage large and nested Zod Schemas by extracting partial validations using shape and unwrap utilities

In this lesson we cover implementing sets and maps in Zod.

Using `z.set`, a schema for string-based amenities is created. We demonstrate how validation works by intentionally introducing errors and customizing error messages for better clarity.

Next, a map is created for existing guestDetails schema using `z.map`, with string keys and an existing `z.object`-based schema. The validation process is shown again by deliberately breaking the schema, such as omitting the age property, which triggers appropriate error messages.


Validate maps and sets using Zod schemas

Use sets and maps in Zod for schema validation, ensuring type safety for both keys and values.

Search

Search Results