Browse Curated Developer Resources on the Best Tools

React

Next.js

TypeScript

JavaScript

Remix

Redux

Supabase

Angular

This course is perfect for those looking for a lightweight alternative to NgRx Store that scales effortlessly.

Tomasz Ducin

course

Scalable Signals Angular Architecture with NGRX Signal Store

Get started with Bootstrap by building a professional landing page.

Lucas Minter

Create Professional Responsive Websites using Bootstrap

Write TypeScript that will keep up with your application as it grows.

Domain Data Modeling using TypeScript Aliases, Brand Types and Value Objects

You’ll learn how to build a dynamic chat application using Fauna Streams and Next.js 14, focusing on the essentials and best practices.

Shadid Haque

Build a Real-time Next.js 14 Chat App with Fauna 

Learn the fundamentals of React Query (a.k.a TanStack Query) by going through the basic API and then implementing search in an employee tracking app.

Simplify State Management with React Query

Learn how the latest JavaScript features can help you improve your codebase.

Learn the Latest ECMAScript Features (ES2024, ES2023, ...)

Compose 3D scenes, models, and animations using familiar Vue components and directives, without having to dive into the complexities of Three.js.


Alvaro Saburido

Create Interactive 3D Experiences with TresJS

Learn everything you need to know to take advantage of signals and be prepared for signal-based components

Modernize State Management in Angular with Signals

Quickly get Supabase running on your machine and keep it in sync with a remote.

Ben Patton

Getting Started with Supabase Local Dev

Create the common types of builds for iOS and Android on EAS. Development builds for local development, Preview builds for internal testing, and Production builds for release.

Kadi Kraman

Build and Deploy React Native Apps with Expo EAS

Quickly develop your pages and components in isolation with Storybook

Michael Chan

A Beginner’s Guide to Storybook 7 with React

Master React Testing Library: Render components, enhance UI querying, optimize testing flow, handle events, & eliminate 'not wrapped in act' warnings.

Daniel Afonso

An Introduction to the React Testing Library

Build full stack applications with AWS CDK powered by TypeScript

Tomasz Łakomy

Full Stack TypeScript with AWS Cloud Development Kit v2

Learn how you can leverage the web platform to build dynamic, modern web apps with Astro while minimizing the JavaScript you send to the client.

Lazar Nikolov

Build a Full Stack Blog with Astro

Jumbotron

Home Page

Recreating web UIs manually can be time-consuming. This lesson demonstrates using Google Gemini's multimodal features to generate UI code directly from screenshots. See how to capture a webpage, provide the image to Gemini, and prompt it to generate a React/Next.js and Tailwind CSS representation. The lesson also covers refining the AI's output using annotated screenshots for corrections and integrating the generated code into a local development project, speeding up the initial UI scaffolding process.

**Workflow demonstrated in this lesson:**

*   Use browser dev tools to capture full-page screenshots of a target website.
*   Upload screenshots to Google Gemini and prompt it to generate UI code (React/Next.js/Tailwind).
*   Refine AI output using additional annotated screenshots for feedback and corrections.
*   Set up a basic Next.js project locally.
*   Use an AI-generated bash script to parse the generated code, split it into components, and integrate it into the local project structure.
*   Install necessary dependencies (like icon libraries) identified during the process.
*   Debug issues in the integrated code, potentially using in-editor AI assistance.
*   Run the local development server to view the AI-assisted UI clone.

**Key benefits:**

*   Reduces the time needed to create initial UI structures based on existing designs.
*   Utilizes AI's image understanding to translate visual layouts into code.
*   Shows a workflow for refinement using visual feedback (annotated screenshots).
*   Provides an example of integrating AI-generated code into a development project.

**Resources** 

[https://www.npmjs.com/package/@johnlindquist/file-forge](https://www.npmjs.com/package/@johnlindquist/file-forge)

**Want to Learn More? Sign-up for my Cursor Workshop!**

[https://egghead.io/workshop/cursor](https://egghead.io/workshop/cursor)

John Lindquist

Visually Clone Websites with Gemini 2.5 Canvas for Cursor

Cursor's default inline edit (`Cmd+K`) has scope limitations, and using the full chat (`Cmd+I`) for simple refactors can be overly conversational. This lesson demonstrates how to create a custom chat mode specifically configured for direct code editing. By setting up a dedicated mode with custom instructions and a keybinding (like `Cmd+E`), you can bypass unnecessary AI chatter and apply targeted, file-aware modifications more efficiently than standard methods.

**Workflow Demonstrated in this Lesson:**

*   Create a "Custom Mode" within Cursor's chat interface.
*   Assign a name (e.g., "Edit") and a preferred AI model.
*   Set a dedicated keybinding (e.g., `Cmd+E`).
*   Configure allowed tools (enable `Edit`, disable `Run`/`MCP`).
*   Use "Advanced options" to enable `auto-run`.
*   Add "Custom instructions" to prompt the AI for direct edits without explanation.
*   Trigger the mode with the keybinding on a code selection to perform edits beyond the selection's scope (e.g., hoisting variables).

**Key Benefits:**

*   Perform refactors and edits beyond the scope of the initial selection, overcoming `Cmd+K` limitations.
*   Achieve a more direct, less "chatty" AI editing experience compared to standard chat (`Cmd+I`).
*   Streamline common AI-assisted modifications with a dedicated keybinding.
*   Gain fine-grained control over the AI's editing behavior using custom instructions.

**Want to Learn More? Sign-up for my Cursor Workshop!**

[https://egghead.io/workshop/cursor](https://egghead.io/workshop/cursor)

Build a Better Edit Tool in Cursor with Custom Agent Modes

Stop waiting for a single AI agent! This lesson demonstrates a powerful workflow to massively parallelize your AI-driven development in Cursor. Learn how to use tools like `file-forge` to package your project context, prompt advanced AI models (like Gemini in AI Studio) to brainstorm features and generate setup scripts, and then leverage a custom `git worktree` CLI tool (`wt`) to automatically launch an "army" of isolated Cursor instances, each tackling a different task on its own branch.

**Workflow Demonstrated / Key Benefits:**

*   **Bundle Project Context:** Use `file-forge` to create an AI-friendly representation of your codebase.
*   **AI-Powered Brainstorming & Scripting:** Prompt a reasoning model (e.g., Gemini via AI Studio) to suggest features *and* generate a shell script (`zsh`/`bash`) to automate setup.
*   **Automated Worktree Creation:** Execute the generated script which uses a custom `git worktree` CLI (`wt`) to:
    *   Create new branches and worktrees for each suggested feature.
    *   Install dependencies automatically (e.g., `pnpm install`).
    *   Launch multiple, isolated Cursor instances.
*   **Parallel AI Development:** Assign different features or implementation approaches to each Cursor agent (Composer) simultaneously.
*   **Efficient Monitoring:** Easily switch between active Cursor projects/worktrees using `Ctrl+R` or OS spaces.
*   **Seamless Integration:** Merge completed features back into your main branch using `wt merge` or use agents to commit, push, and create Pull Requests via the GitHub CLI (`gh pr create`).
*   **Boost Productivity:** Dramatically speed up iteration and experimentation by running multiple AI agents concurrently without conflicts.

This approach transforms your workflow, allowing you to explore multiple development paths simultaneously and integrate the best results efficiently using standard Git practices.

**Resources** 

[https://www.npmjs.com/package/@johnlindquist/worktree](https://www.npmjs.com/package/@johnlindquist/worktree)
[https://www.npmjs.com/package/@johnlindquist/file-forge](https://www.npmjs.com/package/@johnlindquist/file-forge)

**Want to Learn More? Sign-up for my Cursor Workshop!**

[https://egghead.io/workshop/cursor](https://egghead.io/workshop/cursor)

Swarm Intelligence: Massively Parallelize Your AI Agents in Cursor

Creating powerful and context-aware tools for Cursor IDE becomes straightforward when leveraging information directly from your current project. In this lesson, you'll learn how to build a custom MCP (model context protocol) tool that intelligently requests essential details—such as the current project path and conversation summaries—from your Cursor project.

Workflow demonstrated in this lesson:

- Define MCP tool parameters to request specific project details.
- Pass project path and conversation summaries into your MCP tool.
- Automatically write or update files within your current project using these parameters.

Key benefits:

- Automate tasks with precision based on your active project's context.
- Simplify interactions by creating AI-driven CLI commands tailored to your needs.
- Open endless possibilities for integrating external APIs and advanced automation.

Through this practical demonstration, you'll gain a versatile technique for enhancing your development workflow in Cursor IDE.

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

Build MCP Tools Using Project Context for Custom Cursor IDE Automation

Setting up custom MCP (Machine Command Protocol) servers in Cursor can involve tedious steps, such as configuring node paths or referencing additional commands. This lesson shows how to streamline this process by bundling your MCP server directly into a standalone executable.

Workflow demonstrated in this lesson:

- Use a simple MCP server project starter.
- Run a single bundling command to create an executable.
- Right-click the generated executable, copy its full path, and add that directly to your Cursor settings.

Key benefits:

- Eliminates the need for complex node path configurations.
- Simplifies the setup and integration of custom MCP servers into Cursor.
- Makes the server executable instantly accessible within your Cursor environment.

By following this streamlined approach, you can quickly and easily integrate custom MCP servers into Cursor, making your development workflow cleaner and more efficient.

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

Easy MCP Server Setup in Cursor IDE with Bundled Executables

TanStack Router is the foundation for TanStack Start, which is gaining significant attention due to its innovative approach to application development.

This course focuses on getting effective TanStack Router, a modern and scalable routing solution for React applications. You will learn how to:
- set up and scaffold new applications,
- use file-based routing
- create nested routes
- manage dynamic route parameters and more.

The course covers advanced features like route loaders, caching strategies, and lifecycle hooks, which are crucial for enhancing application performance and user experience.

By understanding TanStack Router, you can build more efficient, type-safe, and maintainable applications, leveraging its integration with data fetching libraries like TanStack Query.

This knowledge is essential for developers looking to improve their routing skills and stay ahead in the field.

Up and Running with Tanstack Router and React

Learn TanStack Router for React: set up apps, use file-based routing, manage routes, and boost app performance.


This course provides a practical introduction to MongoDB, a leading NoSQL document database. You will learn how to set up a local MongoDB environment using Docker and then dive into essential database operations. By the end of this course, you will know how to:

- Create and manage MongoDB collections.
- Insert, filter, update, and delete documents.
- Perform complex queries using logical operators and expressions.
- Manipulate data within arrays and nested fields.
- Rename fields and manage date and time properties.
- Execute multiple operations efficiently using bulk operations.

Effectively manage and interact with MongoDB databases. Being proficient with databases is a crucial skill in modern app development.

Get Started with MongoDB

Learn MongoDB setup with Docker, manage collections, documents, queries, data manipulation, and bulk operations. Essential for modern app development.

Finding the *perfect* code editor theme is a myth.  There are always small visual tweaks you'd like to make, but forking and maintaining an entire theme is overkill.  This lesson shows you how to quickly and easily customize *any* theme directly within Cursor (or VS Code) using the `workbench.colorCustomizations` setting in your `settings.json` file.

**The Problem:**

*   No single theme perfectly matches everyone's preferences.
*   Minor visual annoyances (like search highlight colors) can impact focus and productivity.
*   Forking and publishing a theme for small changes is excessive.

**The Solution: `workbench.colorCustomizations`**

This setting allows you to override specific color values of your current theme *without* creating a new theme.  You get fine-grained control over the editor's appearance.

**How it Works:**

1.  **Open Settings (JSON):** Use the command palette (`Cmd/Ctrl + Shift + P`) and search for "Preferences: Open User Settings (JSON)". It is best to create a new editor group to the right, and then open the json settings, so that you can visualize your changes.
2.  **Add `workbench.colorCustomizations`:**  Within your `settings.json`, add a `"workbench.colorCustomizations"` object.
3.  **Use Autocomplete:** Inside this object, start typing "editor." and use Cursor's/VS Code's autocomplete to explore the available customization options.  Examples include:
    *   `editor.findMatchBackground`: Background color of search matches.
    *   `editor.findMatchHighlightBackground`: Background color of the *current* search match.
    *   `editor.findMatchBorder`: Border color of search matches.
    *   `editor.findMatchHighlightBorder`: Border color of the *current* search match.
    *   `editor.background`: Overall editor background color.
    *   ...and many more!
4.  **Set Color Values:** Assign valid color values (hex codes, named colors, etc.) to the properties you want to change.  You can even use transparency (alpha channel) with hex codes (e.g., `#FF000022` for a semi-transparent red).
5.  **Save and See the Changes:**  As soon as you save `settings.json`, the changes are applied *live* to your editor.  Experiment with different colors until you find what works best.

**Benefits:**

*   **Precise Control:**  Tweak individual elements of your theme without affecting others.
*   **No Forking Needed:**  Make personal adjustments without the overhead of creating and managing a separate theme.
*   **Live Updates:**  See your changes instantly as you edit the JSON.
*   **Easy Experimentation:**  Try out different colors and settings quickly.

This lesson demonstrates a simple yet powerful way to personalize your coding environment, improving focus and making your editor truly your own. No need for extensive theme development – just targeted tweaks to make things *just right*.


Personalize Your Cursor/VS Code Theme with workbench.colorCustomizations

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

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."
}
```


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

[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 episode of What's Good, Joel Hooks sits down with Dev Agrawal, a member of the SolidJS core team, to discuss the evolving landscape of web development, AI-assisted coding, and modern framework architecture.

## Episode Highlights

### SolidJS and Modern Framework Architecture
- Detailed comparison between SolidJS and React, highlighting key advantages
- Deep dive into Suspense implementation and reactive state management
- Overview of Dev's work on cross-boundary reactivity in SolidJS
- Discussion of his $7,000 Solid Hack competition winning project
- Exploration of stateful server components with WebSocket updates

### AI-Assisted Development
- Discussion of AI agents managing tasks and grooming backlogs during meetings
- Exploration of using AI tools like Cursor for development
- Joel shares his experience building [JoelFit](https://joelfit.app), a full-stack application developed primarily through AI prompting
- Analysis of AI's current limitations and the importance of human guidance in development

### Emerging Technologies and Trends
- Analysis of React Server Components and their impact on the ecosystem
- Discussion of Cloudflare Durable Objects as individual compute units
- Introduction to Zero Sync and its implications for local-first applications
- Exploration of incremental view maintenance and its performance benefits
- Overview of Vite 6's improvements for server components and meta frameworks

### Featured Projects and Resources
- [JoelFit (code)](https://github.com/joelhooks/joelfit) - Joel's AI-assisted development project on github
- [Solid Suspense Demo v2](https://github.com/devagrawal09/solid-suspense-demo-v2) - Dev's demo showcasing Solid's advantages
- [Building Asynchronous UIs Without the Hassle](https://youtube.com/watch?v=pX5r_jTLbvw) - Dev's conference talk

## Key Takeaways
- SolidJS offers built-in support for async operations without React's bailout issues
- The entire Solid ecosystem was built with suspense support from v1
- Durable Objects are often misunderstood - they're individual compute units rather than just shared state
- Zero Sync's incremental view maintenance pairs particularly well with Solid's architecture
- React has moved away from traditional SPA towards full-stack architecture
- Framework choices continue to evolve with different approaches to reactivity and state management

## Connect with Dev
- Watch Dev's talk on [Building Asynchronous UIs Without the Hassle](https://youtube.com/watch?v=pX5r_jTLbvw)
- Check out his [Solid Suspense Demo](https://github.com/devagrawal09/solid-suspense-demo-v2)

---

*Note: This episode was recorded in January 2024 and discusses emerging technologies and trends in web development.*

Full-Stack Signals in Solid, AI Development, and the Future of Web Frameworks

A deep dive into AI-assisted development, modern web framework architecture, and emerging technologies like full-stack Solid signals and local-first databases.

TypeScript v5.8 ships with the new `erasableSyntaxOnly` compiler flag.

It disallows using the TS features which emit additional JavaScript output, due to being outside of official [ECMAScript specification](https://ecma-international.org/publications-and-standards/standards/ecma-262/).

In this lesson we'll see what TypeScript features get affected and why exactly.

Check out the [playground link with the code](https://www.typescriptlang.org/play/?erasableSyntaxOnly=true&isolatedModules=true&ts=5.8.0-dev.20250129#code/DYUwLgBA9gRgVgLggbwgOwIYFsRIM5gBOAlmgOYQC+EAvCgFATra4QDkAUlABZoQAiUEG3qV69EGgCuWCAFkQAE2IBjDMADKABxAri6sAE8GTAOKSQhdQAUrKsMQdQ0l2u3MurwWxnuPizpZsADSMEBpShGQgzm5sEVExaCFh1kr6RKr6fHRsacoYmXoYyaFMAMIYhMpQwFBkxARxldUBdQ0EKUwAciCRtfWNkLm9-e1DImKgkHg6xcBGSArKappz+gvGdMuq6tq6G0YAdKOEAx1g4kY6EAD6O6v780ZxptZsEAA+7BoAqgBKpgAogB5bofb55IH8ACSAEEACr-GHleHgr7scpw-6wkEAGRBphhGgREPY3SBAPxhOJpPo0zuswOBkMSHu6Ue6xZcQpVIJRJJIgkAA8tFBCJAVMAMHg8AIoPZxSYICpnARCFJFYQABRhJhaKQwYCqZg4fCZchlJgQLRnMC6e2KCCGEBVPAggBmQNFlmIkhUrGkWBglit+pIADdCiAIEznqz5By9lzNmEAJQoMR6m2G40qCDRMCCLUwtAeqDatPmkjkZXW62EcCRPgAA34hCOEAAJMgwNxGkdMDhKGH69anocEz2HsnmZsANp9gdxycAXRH2bHEG9OhI-tYPaXeCOLrdnp3vv31FPhDwLYA3NmxFmhyBZr4YzPgIIsBhSMqQFFcVIA9KQ0D8WI8BkX8SAALxAYswHFbVFAVJDCCQRDxSrWMLQoZBs0bMBmwgFsIiwGCp2QVCtSOQssMIUty0rSgHzCZ96CAA).

Use the erasableSyntaxOnly TypeScript compilation flag

TypeScript v5.8 ships with the new `erasableSyntaxOnly` compiler flag, which disallows using TypeScript enums, class property accessors and namespaces.

Fetch paginated data with React 19 `use`. Set a promise as the initial value in `useState` then return a function from your custom hook to update that promise with a new one to load the next page of data.

Fetch and render paginated data with React 19 use

Fetch paginated date with React 19 use. Update the promise useState is storing for each page of data.

This lesson demonstrates how to utilize DeepSeek's R1 model to access its reasoning capabilities and then seamlessly transition to other models for subsequent tasks. By extracting the reasoning output from DeepSeek R1, you can leverage its powerful reasoning while gaining the speed, cost efficiency, and configuration flexibility of alternative models. This two-phase approach begins with DeepSeek’s new R1 model, praised for its open-source nature and value. You then gain the adaptability to switch to other models depending on your needs or existing workflows. This lesson provides a step-by-step walkthrough of this process, along with demo code to help you implement this technique yourself.

Combine DeepSeek R1 Reasoning with GPT 3.5 Turbo for the Cheapest, Fastest, and Best AI

While much focus in AI has been on optimizing input and generating concise outputs, a new model in Google's AI Studio dramatically expands output possibilities with a capacity of 65,000 tokens. This represents a significant shift, opening doors to new application scenarios, especially for developers and creators. This lesson explores a practical and immediately useful scenario: leveraging this large output capability within Google's AI Studio to generate extensive sample datasets for your projects. Whether you are developing a new application, building a resource, or require robust datasets for testing and validation, this model offers a powerful solution. We'll demonstrate how to move beyond the constraints of short responses and utilize the full potential of large output models to generate the data volume and variety you need, enhancing your development workflow through Google's AI Studio.

AI Studio's New 65k Output Opens Exciting Possibilities

This lesson explores how to use Cursor to generate and maintain English specifications as a form of living documentation. Learn how these automatically created documents can serve as a consistent and up-to-date representation of your code's behavior. The video highlights how reviewing and refining these English specifications can help ensure that code modifications align with the intended purpose and that documentation accurately reflects the current codebase, promoting better long-term code maintainability and clarity.

Here's the "english-spec.md" used in the video:

```markdown
> You are an AI specialized in analyzing source code and producing structured, plain-English representations of its functionality.  
>  
> **Your Task**:  
> 1. Read and interpret the code I provide.  
> 2. Produce a technical, English-only summary of what the code does.  
> 3. Use headings and bullet points to clearly outline the roles of each function, class, variable, or important logic block.  
> 4. **Do not include any actual code** in your final output. Instead, translate the code’s content into an English explanation (like a specification or documentation).  
> 5. Keep the explanation concise but thorough. Focus on explaining the purpose, process, and relationships between functions or modules in the code.  

**User Prompt to the AI**:

> **Instruction**: Convert the following code into a single file of pure English text that outlines exactly what each part of the code does. Use bullet points, headings, and descriptive language. Do not show any code—only explain how the code behaves. This is intended to serve as a human-readable spec or “translation” of the code.  
>  
> **Code**:  
> ~~~  
> [PASTE YOUR CODE HERE]  
> ~~~  

**Example Input/Output #1**:

- **Example Code (Input):**
  ~~~js
  // example1.js
  const greetUser = (userName) => {
    const greeting = `Hello, ${userName}!`;
    console.log(greeting);
  };

  greetUser("Alice");
  ~~~

- **Example Explanation (Output)**:
  ~~~
  # Overview
  - This file defines a single function which greets a user by name and prints a message to the console.
  
  # Function: greetUser
  - Accepts one parameter (`userName`).
  - Constructs a greeting string that combines static text with the `userName`.
  - Outputs the greeting using `console.log`.

  # Behavior Flow
  - The function is called with the argument "Alice".
  - Upon invocation, "Hello, Alice!" is logged to the console.

  # Key Points
  - Shows how to create a greeting with a dynamic name.
  - Demonstrates basic string interpolation and console logging.
  ~~~

**Example Input/Output #2**:

- **Example Code (Input):**
  ~~~py
  # example2.py
  class Calculator:
      def __init__(self, initial=0):
          self.value = initial
      
      def add(self, amount):
          self.value += amount
      
      def subtract(self, amount):
          self.value -= amount
      
      def get_value(self):
          return self.value

  calc = Calculator(10)
  calc.add(5)
  calc.subtract(3)
  result = calc.get_value()
  print(result)
  ~~~

- **Example Explanation (Output):**
  ~~~
  # Overview
  - This file defines a `Calculator` class that keeps track of an internal numerical value and provides methods to modify it.
  
  # Class: Calculator
  - **Constructor** (`__init__`):
    - Accepts an optional initial value (default is 0).
    - Stores the initial value in a `value` property.
  - **Method: add**:
    - Takes an `amount` and increments the internal `value` by that amount.
  - **Method: subtract**:
    - Takes an `amount` and decrements the internal `value` by that amount.
  - **Method: get_value**:
    - Returns the current internal `value`.
  
  # Behavior Flow
  - An instance of `Calculator` is created with an initial value of 10.
  - The `add` method is called with 5, raising the value to 15.
  - The `subtract` method is called with 3, lowering the value to 12.
  - The `get_value` method is called to retrieve the current value (12).
  - The result (12) is printed to the console.

  # Key Points
  - Demonstrates basic OOP with a class that manages state.
  - Showcases constructor, addition, subtraction, and retrieval of a stored value.
  ~~~  

---

## Final Prompt

Below is a full, combined version of the prompt you can provide to an AI to guide it in generating the English-only, bullet-pointed explanation. Feel free to modify or adapt this as needed:

~~~
You are an AI specialized in analyzing source code and producing structured, plain-English representations of its functionality.

Your Task:
1. Read and interpret the code I provide.
2. Produce a technical, English-only summary of what the code does.
3. Use headings (e.g. # Overview, # Functions, # Classes, # Behavior Flow) and bullet points.
4. Do not include any code in your final output—only explain how the code behaves.
5. Keep it concise but thorough, focusing on purpose, process, and relationships between functions or modules.

Below are some examples of how code might be transformed into an English-only explanation:

Example Input:
-------------------
~~~js
// example1.js
const greetUser = (userName) => {
  const greeting = `Hello, ${userName}!`;
  console.log(greeting);
};

greetUser("Alice");
~~~
Example Output:
-------------------
# Overview
- This file defines a single function which greets a user by name and prints a message to the console.

# Function: greetUser
- Accepts one parameter (`userName`).
- Constructs a greeting string that combines static text with the `userName`.
- Outputs the greeting using `console.log`.

# Behavior Flow
- The function is called with the argument "Alice".
- Upon invocation, "Hello, Alice!" is logged to the console.

# Key Points
- Shows how to create a greeting with a dynamic name.
- Demonstrates basic string interpolation and console logging.


Example Input:
-------------------
~~~py
# example2.py
class Calculator:
    def __init__(self, initial=0):
        self.value = initial
    
    def add(self, amount):
        self.value += amount
    
    def subtract(self, amount):
        self.value -= amount
    
    def get_value(self):
        return self.value

calc = Calculator(10)
calc.add(5)
calc.subtract(3)
result = calc.get_value()
print(result)
~~~
Example Output:
-------------------
# Overview
- This file defines a `Calculator` class that keeps track of an internal numerical value and provides methods to modify it.

# Class: Calculator
- **Constructor** (`__init__`):
  - Accepts an optional initial value (default is 0).
  - Stores the initial value in a `value` property.
- **Method: add**:
  - Takes an `amount` and increments the internal `value` by that amount.
- **Method: subtract**:
  - Takes an `amount` and decrements the internal `value` by that amount.
- **Method: get_value**:
  - Returns the current internal `value`.

# Behavior Flow
- An instance of `Calculator` is created with an initial value of 10.
- The `add` method is called with 5, raising the value to 15.
- The `subtract` method is called with 3, lowering the value to 12.
- The `get_value` method is called to retrieve the current value (12).
- The result (12) is printed to the console.

# Key Points
- Demonstrates basic OOP with a class that manages state.
- Showcases constructor, addition, subtraction, and retrieval of a stored value.

---

**Now**: Please apply the same conversion process to the following code. Convert it into a plain-English document that describes what the code does in detail, using bullet points and headings. Create the document next to the original with the filename as `${fileName}.md`. Do not include any source code in the output—only the explanation:

[INSERT YOUR CODE HERE]
```

Programming in English with Cursor

In this lesson, you'll learn how to enhance the accuracy of components generated by Cursor Composer by aligning your project's package.json with Cursor's rules. We'll guide you through extracting the list of installed packages from your package.json and incorporating them into your .cursorrules file, along with brief descriptions of their functionalities. By providing Cursor with this contextual information, you'll enable it to generate components that are more precise and functional on the first attempt. The lesson includes demonstrations of component generation both with and without these enhancements, highlighting the improvements in accuracy and efficiency.

Bite-Sized Screencasts for Web Developers that Hate Long Boring Videos