 Courses from Colby Fayock

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

The “happy path” of our application is pretty buttoned up. If all goes well, they’ll have a good time browsing and potentially create new events, but what happens when all goes wrong? We’re not doing any error handling or catching any exceptions, so they might be stuck with some ugly error or worse, the application might silently fai leaving them totally and utterly confused.

Appwrite exposes their AppwriteException error instance which provides all the information we need for the variety of errors that we may hit when working with Appwrite’s services including a user not being logged in, not having access, or if we accidentally defined the wrong ID somewhere. We can use this information to not necessarily dynamically show the exact details of what failed (though we can), but help explain from an application user’s perspective what went wrong and how they can fix it.

In our Error Handling lesson, we’ll improve our UX by first seeing how we can catch errors that occur when interacting with the Appwrite SDK. We’ll then determine if it is indeed an instance of AppwriteException or a generic error which will allow us to use that information to show specific messages to our users depending on the context of their interaction. We’ll also see some different examples of patterns we can take for how we use that information to show UI, so we have a more manageable way of handling errors throughout our app.

What You’ll Learn
Inspect and use AppwriteExceptions to determine what error occurred
Dynamically display UI based on errors received


Catch & Handle Errors with React & the Appwrite Web SDK

After the previous lesson, our application is now locked down, only allowing users with specific permissions to perform specific actions. Particularly here, we’re interested in our Admins ability to delete events. But we’re left with a problem. Our app currently doesn’t know if someone is an Admin or not, so we just show a Delete button to anyone and let it fail if they’re not. Bummer.

The good news is we can use the Appwrite Get Teams endpoint where we can first look at all the Teams our user is currently included in and try to see if Admin is in that list. This will allow us to tack on some additional information to our global state, which we can take advantage of to dynamically show the Admin-only bits in our app.

In this lesson, we’ll look up all of the Teams for our current user. We’ll look through that list and see if we find a Team object where the ID matches the ID of our Admin team which we can handily find in the Appwrite console. And once we confirm whether or not they’re an Admin, we’ll leave the Delete button hidden, or show it, depending on their access level.

**What You’ll Learn**
- Get a list of the Teams a user is associated with
- Determine if a user is in a Team by its ID
- Dynamically show and hide UI based on access privileges

**Resources**
- [List a user’s Teams](https://appwrite.io/docs/client/teams?sdk=web-default#teamsList)


Get a User’s Team Access & Grant Admin Privileges in Appwrite and React

One potential hiccup with our application is the fact that literally anyone can do literally anything in our application. This is… a major security hole! This was expected though, as we wanted to make this thing first work. But now’s the time we lock things down!

Appwrite gives us the ability to set granular permissions where we’re able to define exactly who we want to access and what. In our case, we want anyone to see the events, but we don’t want everyone to create events, only people who are logged in (you can customize this). And we don’t want just anyone logged in (or out) to delete events, we only want Admins or specific users to be able to delete any of the events.

Here we’ll work through configuring our granular permission where we’ll start off with locking down adding events including Documents and Files to only logged in users. Once that’s accomplished, we’ll create a new Team for Admins, which will allow us to designate specific users that we want to be able to give additional access to where in this case, we’ll provide the ability for Admins to delete events.

**What You’ll Learn**
- Define specific permissions to allow only logged in users to Create Documents and Files
- Create a new Team to designate Admins
- Add additional permissions for Admins to delete Documents and Files

**Resources**
- [Permissions](https://appwrite.io/docs/permissions)


Configure Granular Permissions for Restricting Read, Write, and Delete Access in Appwrite

Our authentication system is pretty solid and works well, but if we try to start using it anywhere other than the one spot we’ve used it so far, we’re going to be copying and pasting the same request over and over within the application. On top of that just being a pain to manage, we’ll also be making duplicate, unnecessary requests that just waste time and bandwidth.

React gives us a few options for how we can mitigate this. Particularly, we’ll be looking at the Context API, which will allow us to easily access state in components that are defined in the same tree as whatever component we wrap with that Context, such as the root of the app, meaning all components will be able to access that Context.

In this lesson, we’ll walk through all the bits of how to make this work, which includes creating a new hook where we define that Context and the Provider which will wrap our application. We’ll then define and set up Types for the state that we’ll pass through our context, migrate our auth-related requests to this new hook, and dynamically update our UI to make use of our new hook including our login flow, hiding the Add Event for guests, and even redirect user’s away from pages that require authentication. 

**What You’ll Learn**
- Create a new React hook
- Set up a new instance of Context using createContext
- Define Types for application Context
- Create a Provider that allows us to access our Context globally
- Manage global state with useState and pass it through app with Context
- Request, store, and manage a user’s Session globally
- Dynamically show and hide UI based on global auth state

**Resources**
- [React Context](https://react.dev/learn/passing-data-deeply-with-context)



Share Authentication & Appwrite Session State Globally with React Context

When logging into any application, the expectation is you can log out. Maybe it’s because you want to prevent someone else using the device from messing with your account, but whatever it is, we ultimately want to destroy the current session both by locally signing out and also letting Appwrite know that the session is no longer active.

The Appwrite SDK has an easy method to handle this where we don’t technically need to even pass in the current session ID, we can just simply tell it we want to delete the current session for the device like we did in the last lesson, and that’s it!

So we’ll see how we can use the Delete Session endpoint to do just that, passing in the “current” key like before to specify we just want to clear the device’s active session, and then clearing local state to re-render the UI and avoid any stale session information from sticking around.

**What You’ll Learn**
- Delete the current session
- Clear local state after deleting a session

**Resources**
- [Delete at Session](https://appwrite.io/docs/client/account?sdk=web-default#accountDeleteSession)



Delete the Current Session in Appwrite to Log Out an Authenticated User

We’re able to log people in, but how does the application know this? Appwrite can see this if we try to make a request based on the securely stored session cookie, but we need to first know if they’re logged in before trying to submit a request for a particular task, otherwise we’re making a lot of assumptions within our UI.

To work through this, we’ll first get our current Session using the Get Session endpoint, which will not only allow us to pass in a Session’s ID to get the details of that Session, but also pass in the key of “current” which will give us well… the current Session. If they’re logged out, we won’t do anything, but if they’re logged in, we’ll then store that Session in state, which will be our indicator for whether or not we should show Log In or Log Out in our navigation.

What You’ll Learn
- Get the details of the user’s current session (if logged in)
- Dynamically show login and logout links based on authentication state

Resources
- [Or Get the Current Session](https://appwrite.io/docs/client/account?sdk=web-default#accountGetSession)


Get the Current Session from Appwrite of an Authenticated User in React

Up until this point, we’ve given our users free range to do whatever they want in their app. To be clear, we’ve done this intentionally, because we wanted to make things work, but now's the time to lock things down so only logged in users can perform actions in our app. But first, we need some kind of authentication method.

We’ve been able to see how the Appwrite SDK makes working with these different services easy, but authentication takes this to another level. Authentication can be tricky. When we log a user in, they expect to be able to refresh the page and stay logged in, but to do this, we need to store something like an access token somewhere and there are a lot of security implications around how you do this! But Appwrite handles all of this for us, securely storing a cookie, so that any requests we make with our active session will pass that along and handle it for us.

But for now, we just want to log them in, so we can easily get this process started by kicking off a new Magic Link session, verifying it, and getting our active session ready to go for interacting with it.

We’ll start off by kicking an email to our user by creating a Magic Link session. Through this, we’ll want to also pass in the URL of the location we want our actual Magic Link to take them to when returning to the application, which in our instance, is a session page that will include URL parameters to read. Once they’re there, we’ll use URLSearchParams to read the param values and pass them to the verification endpoint to confirm the session, along with some UI updates to give feedback for their actions.

**What You’ll Learn**
- Register a new user or log in an existing user by creating a new Magic Link session
- Verify a new session created from a Magic Link
- Read an email from a form input
- Get parameters from a URL with URLSearchParams
- Show a message or redirecting after successfully submitting a form

**Resources**
- [Create a Magic Link session](https://appwrite.io/docs/client/account?sdk=web-default#accountCreateMagicURLSession)
- [Verify a Magic Link session](https://appwrite.io/docs/client/account?sdk=web-default#accountUpdateMagicURLSession)
- [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)


Create & Verify New Authenticated Users in React with a Magic Link Session from Appwrite

We have a list of some pretty amazing events, but two of your event managers just submitted the same event twice! :gasp: Does that mean they have to manually edit the Document’s fields? Likely not… we don’t want people having to manually edit a database. Instead, we can give the option to delete events, so that whether it's a typo or an invalid event, we can quickly get rid of it.

As we can probably expect at this point, the Appwrite SDK not only gives us the flexibility to create, but also delete any Document or File we want. So that means, we can easily clean things up by passing in the ID of the Document or File we want and it's gone! The tricky part though, is how do we make sure we always delete the File associated with the Document so we don’t end up with a bunch of extra unnecessary files getting stored.

In this lesson, we’ll first learn how we can use the Delete Document endpoint to delete any of our Database Collection entries. As we know, there’s a field within that Document that references a file, so we’ll see how we can first use that reference ID to delete the associated File, then continue on with the Document deletion process. And to do all of that, we’ll make sure we have the right permissions configured to avoid making unauthenticated requests!

**What You’ll Learn**
- Delete a Document from a Database Collection by ID
- Delete a File referenced in a Document by ID
- Configure Delete permissions for Documents and Files

**Resources**
- [Delete a Document](https://appwrite.io/docs/client/databases?sdk=web-default#databasesDeleteDocument)
- [Delete a File](https://appwrite.io/docs/client/storage?sdk=web-default#storageDeleteFile)


Delete an Appwrite Document from a Database Collection in React

Events are exciting in nature, but a wall of text in an app… isn’t the most exciting. We can liven this up by using images within our application, particularly allowing our event submitters to attach a photo that represents that particular event whether it's an actual photo or something that looks along the lines of what to expect.

But this isn’t as simple as storing a string of text in a Database. Images and files generally are complex and need more support to handle them, which is where the Appwrite Storage service comes in.

We’ll first learn how we can read a file from a form’s filepicker input and read the information about an image like the width and height, which will help us to display that image confidently later on. We’ll then see how we can spin up a new Storage Bucket, start to upload our files, store a reference to that image in the related event Document, and even display the images once permissions are configured.

**What you’ll Learn**
- Read a file from a form filepicker input
- Extract metadata like width and height from a selected image
- Create a new Appwrite Storage Bucket
- Configure permissions for a Bucket
- Upload an image file to a Bucket
- Store a file ID and metadata as a reference on a Database Collection Document
- Generate a preview URL for an image file

**Resources**
- [Create a File](https://appwrite.io/docs/client/storage?sdk=web-default#storageCreateFile)
- [Storage](https://appwrite.io/docs/storage)
- [Get File for Preview](https://appwrite.io/docs/client/storage?sdk=web-default#storageGetFilePreview)




Upload an Image File in React to an Appwrite Storage Bucket

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

Part of the appeal of our events site is not only being able to show cool events, but allowing others to submit their own events. But so far we’ve only worked with data that already exists in our database, how do we create data?

The Appwrite SDK gives us the ability to easily create a new Document by passing in our data. Additionally, the SDK provides helpers that make dealing with things like unique Document IDs easy. But part of the trick with creating new data, is we need a mechanism to input data, which is where we’ll see how we can read a form in React with Typed out data, so that we can pass it along formatted to Appwrite.

We’ll first learn how to create a new Document using the Appwrite SDK. This includes the ID helpers for generating a unique ID, formatting dates to the required format, and using our existing Types for that creation process. When passing along our Types, we’ll omit the ID which we’ll only get once the data exists in the first place. We’ll then see how we can dynamically grab data from a form, rather than hardcoding the input data, and open up access so that we have permission to create our new Document in Appwrite.

**What You’ll Learn**
- Create a new Document in a Database Collection
- Use the Appwrite ID helper to generate a unique ID
- Format a date in the ISO format
- Use the TypeScript Omit utility to use all properties of a Type  except the ones omitted
- Configure Create access for Documents
- Read and set Types for data from a form

**Resources**
- [Create a Document](https://appwrite.io/docs/client/databases?sdk=web-default#databasesCreateDocument)
- [Permissions](https://appwrite.io/docs/permissions)
- [Date.toISOString](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
- [TypeScript Omit](https://www.typescriptlang.org/docs/handbook/utility-types.html#omittype-keys)


Create a new Document in an Appwrite Database Collection

Showing a grid of events is a great way for someone to browse, but once one catches their attention, they want to dig in for more info, or maybe they want a way to share a direct link to that event. Either way, we want to be able to have a page that requests an individual event, not a whole list of them.

We have some flexibility in how we request our data with the Appwrite SDK, where we can use the Get Document endpoint to pass in a single ID and get all the data for that particular event. This will allow us to work together with our router to dynamically get that value based on navigation and look up that individual event.

We’ll make this work by first requesting a single document by passing in a static example ID. Later, we’ll use the router to get our individual event’s ID dynamically. In order to clean things up, we’ll see how we can start to refactor and abstract some of our data transformation logic as well as how we can use Appwrite’s included Types to make sure we’re fully type-safe when working with Documents.

**What You’ll Learn**
- Request a Document by ID from a Database Collection
- Import and use the Appwrite Document Type
- Abstract and share data transformation functions
- Type local state when using the useState hook
- Use a router to dynamically use a path ID variable for requesting a Document

**Resources**
- [Get a Document](https://appwrite.io/docs/client/databases?sdk=web-default#databasesGetDocument)
- [Routing in React.js with Wouter](https://www.youtube.com/watch?v=nvGhGSmEQZU)



Get a Single Document from a Database Collection with the Appwrite SDK

In the last lesson, we set up our new database and now it’s time to read our Documents and list them out in our project. This is where we’ll start working with the Web SDK to programmatically request those event Documents and dynamically pull them into our application so that when someone adds a new one, our application will show it right away.

We’ll first start out by learning how to use the Databases service. Once that’s ready to go, we’ll use the List Documents endpoint configured to pull the data into our application from our previously created Database Collection. We’ll then define a new Type for our data to make sure we’re working with our event safely throughout the app.

**What You’ll Learn**
- Configure the Databases service
- List all Documents in a Database Collection
- Define Types for our event data
- Use environment variables to manage service IDs

**Resources**
- [List All Documents](https://appwrite.io/docs/client/databases?sdk=web-default#databasesListDocuments)


List All Documents from an Appwrite Database Collection

Displaying a list of events in an app ultimately relies on a location to store the data that supports those events. It’s important that this mechanism is flexible and reliable so that we can store the different types of data we need, as well as having the ability to lock down that data in the future with custom permissions.

One of the many services Appwrite provides is being able to create and manage Databases, which allows us to easily interact with the data for our events. By building our database with Appwrite, we can easily connect to the other services Appwrite provides. But for now, this is a perfect location to store each of our events.

We’ll start off by creating a new Database and Collection where we can store our data in Documents. We’ll then walk through creating the basic fields we’ll need for our Documents, how to configure the data types for each field, and opening up permissions so we can start to interact with our Collection programmatically followed by creating our first Collection Document in the UI.

**What You’ll Learn**
- Create a new Database and Collection with the Appwrite UI
- Define a schema and fields with data types for the Collection Documents
- Configure permissions for new the Collection
- Add a new Document using the UI

**Resources**
- [Appwrite Databases](https://appwrite.io/docs/databases)


Create a new Database & Collection in Appwrite

Building projects on top of other services usually means interfacing with some kind of API. If you’re lucky, you’ll get an SDK, which makes it easier to interact with that API in a way that’s native to the environment you're working in.

Since we're building a web app, we can leverage the Appwrite Web SDK to simplify building a full stack application on top of the various Appwrite services.

We’ll walk through setting up a new Appwrite account, creating a project, and configuring our new project along with the SDK inside of our app.

**What You’ll Learn**
- Create a new Appwrite project
- Install the Appwrite Web SDK in a React project
- Configure the Web SDK using the Appwrite endpoint and a Project ID

**Resources**
- [Appwrite](https://appwrite.io/)
- [Getting Started for Web](https://appwrite.io/docs/getting-started-for-web)
- [Appwrite Web SDK](https://www.npmjs.com/package/appwrite)


Install & Configure the Appwrite Web SDK

Our goal is to create an application that allows us and others to create and manage event listings to help others discover events in their area. The first step in getting there is getting set up with a new application that we can start building upon.

In this first lesson, we’ll dig right in by creating a new React application on top of Vite. We’ll learn how we can use an existing template cloned to our local filesystem using degit, to ultimately give us the ability to more quickly start a new project with some templated groundwork that we can use between this and other new projects.

We’ll explore our new application including some of the basic UI and routing that will allow us to jump right into getting started wiring it up with Appwrite.

**What You’ll Learn**
- Create a new React app from a starter template
- Get familiar with how the app is organized including routing

**Resources**
- [Starter](https://github.com/colbyfayock/livebeat-starter)


Create a New React App with degit

There are two major categories that you'll encounter when you start to build Full Stack applications.

You have:
💽 Database Management 
👥 Authentication

Both of these contain their unique set of challenges and layer on top of each other as you build out your application.

You want to be able to Create, Read, Update, and Delete data from your database and also make sure that only the right users are performing these actions that you specify.

That is why this course is set up around these two categories.

You'll learn everything you need to about managing data using a service called Appwrite within your React application. Using Appwrite, you'll be able to create a database, upload files, and manage users. 

You'll start out by building out the database while purposefully ignoring authentication/authorization through out the application. 

The second part of the course will have you layer on auth so that you can enable users to log in and scope specific actions to roles that you'll create.

This course is focused on the full stack nature of web development so we will start with almost all of our UI built out for us. You can explore the course repository to get familiar with what components are available. 

Full Stack with React and Appwrite

OpenAI's technologies offer a range of AI-powered tools and capabilities, making it easier for developers to build intelligent, responsive, and user-friendly applications.

openai

We can teach an AI model to better understand the information we want to generate responses from. To do that, we can use training data in a particular format, JSONL.

Once we have our data generated and uploaded to OpenAI, we can now use it to fine tune or customize a model to provide better results.

We'll use the training data we generated and uploaded in previous lessons to create a new fine-tuned model based off of the OpenAI davinci model.


- [https://platform.openai.com/docs/api-reference/fine-tunes/create](https://platform.openai.com/docs/api-reference/fine-tunes/create)

Fine Tuning OpenAI Models with Training Data Files

Once we have our training data, we need to a way to deliver it to OpenAI.

We can do that by uploading our training data file to OpenAI directly where we can then reference that with our fine tuning.


- [https://platform.openai.com/docs/api-reference/files/upload](https://platform.openai.com/docs/api-reference/files/upload)


Uploading Training Data Files to OpenAI for Fine Tuning AI Models

Using the models that OpenAI provides will get you really far, but their knowledge base can be somewhat limited for particular information or if its past a certain date that the model doesn't support.

To improve the experience, we can train models to have a better understanding of the data we want to work with, whether that's documentation for a new developer tool or guiding the model to respond closer to how how we expect.

The problem—is you need a lot of data in a specific format to do this and its not very practical to write it all our by hand. So we can instead use GPT, where by providing our data, we can ask it to generate JSONL training data for us and format it in a way that we can use to fine tune our model.


- [https://platform.openai.com/docs/guides/fine-tuning/prepare-training-data](https://platform.openai.com/docs/guides/fine-tuning/prepare-training-data)

Generating & Preparing JSONL Training Data with GPT for Fine Tuning an OpenAI Model

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

node

With a reliable data API, we can start using our generative output in creative ways, including feeding that directly into a new generation like creating an image based off of a blog post.

We'll look at taking a GPT-generated blog post and feeding it into DALL-E along with some stylistic prompt engineering to generate an image for our post.

Use Chat Completions for Image Generation Prompts with DALL-E

An important part in creating a data API whether based on generative systems or not is being able to reliably generate responses in the format you need. Variable data structures and irrelevant information could break your application or frustrate the users of your API, resulting in downtime or lost customers.

Using the messaging API, we can train GPT to become more aware of our needs by using System roles to instruct GPT on behavior and User to Assistant examples to give GPT precedent to base its next response on.

[https://platform.openai.com/docs/guides/chat/introduction](https://platform.openai.com/docs/guides/chat/introduction)

Training GPT Using Roles & Message Examples for Better Chat Completions

Hey Everyone 👋,

John Lindquist here with the third issue of AI Dev Essentials! Another week, another whirlwind of updates in the AI development space. We saw Google drop Gemini 2.5 Flash, OpenAI counter with o3/o4-mini and a new Codex CLI, Anthropic beef up Claude with research tools, and continued evolution in the MCP and agent framework landscape. Personally, I've been digging into Gemini 2.5 Flash – it's impressive to see Google pushing the performance frontier for smaller models and comparing it directly against the competition like O4-mini. Let's dive in!

___

### New egghead.io Lesson This Week:

* **[Generate and Debug MCP Servers from Scratch using GitHub Examples and AI](https://egghead.io/generate-and-debug-mcp-servers-from-scratch~k98ad):** Building complex components like Model Context Protocol (MCP) servers from scratch can be challenging, especially without good reference implementations. This lesson demonstrates a powerful workflow combining the `ghx` CLI tool (a wrapper I built for the GitHub CLI - find it [here](https://www.npmjs.com/package/@johnlindquist/ghx)) with AI assistants (like Google's AI Studio and Cursor's agent) to overcome this hurdle. Learn how to scrape real-world examples from GitHub using `ghx` ([see scraped examples here](https://gist.github.com/johnlindquist/b19673bbf6a396406dff869beecace1d)), feed them to an AI to generate a new server, and then integrate and debug it within Cursor. It's a practical look at bootstrapping complex tools using AI and targeted code searching.

___

Here are the highlights that caught my eye this past week:

## Model & Major Platform Updates

* **Gemini 2.5 Flash Arrives:** Google released Gemini 2.5 Flash ([Google Developers Blog](https://developers.googleblog.com/en/start-building-with-gemini-25-flash/)), their first unified reasoning model with thinking budgets. It's positioned as a high-performance, cost-effective option. Notably, Google's benchmarks included comparisons against OpenAI's very recent O4-mini, drawing praise for transparency ([Nathan Lambert](https://x.com/natolambert/status/1912958672881303943)). It's available via the Gemini API, AI Studio, Vertex, and the Gemini app. The [Live API docs](https://ai.google.dev/gemini-api/docs/live) are also updated.
* **OpenAI Counters with o3/o4-mini & Codex CLI:** OpenAI launched [o3 and o4-mini](https://openai.com/index/introducing-o3-and-o4-mini/), highlighting their agentic capabilities and tool use during Chain-of-Thought. Alongside these, they released the open-source [Codex CLI](https://github.com/openai/codex), a coding agent designed to leverage these new models. Interestingly, the OpenAI dev behind Codex CLI was spotted [using Cursor](https://x.com/chuhang1122/status/1912786904812294312).
* **Claude Gets Research Superpowers:** Anthropic rolled out a major [Claude upgrade](https://x.com/jowettbrendan/status/1912446262756151732) introducing a "Research" agent capability. It can search the web and internal docs, chain queries, and explore topics agentically, building citations along the way. They also added Google Workspace integration (Gmail, Calendar, Docs) for paid users. (Official blog post link pending confirmation).
* **Cursor 0.49 Update:** The latest Cursor update ([Changelog 0.49](https://www.cursor.com/changelog/0-49)) brings several enhancements: improved Cursor Rules generation and attachment, better chat history access, built-in diff reviews, image support in MCP context, agent command editing/skipping, global ignore files, added models (Gemini 2.5 Pro, Grok 3, GPT-4.1), and project structure context for the agent. [AGIdevice](https://x.com/agidevice/status/1913575514670776520) shows how to enable the beta features.

## Tooling & Protocol Developments

* **MCP Nuances:** David Cramer cautioned against simply [proxying OpenAPI specs via MCP](https://x.com/zeeg/status/1913289979368796671), arguing it misuses the protocol and ignores LLM limitations in tool selection and JSON handling.
* **MCP Transport Clarification:** Harald Kirschner clarified the newer "Streamable HTTP" transport ([MCP Spec](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports)), noting it's primarily HTTP-based, with Server-Sent Events (SSE) as an optional upgrade for streaming server messages, deprecating the older standalone SSE transport. Discussions on implementation and future streaming enhancements are ongoing ([TS SDK Issue #220](https://github.com/modelcontextprotocol/typescript-sdk/issues/220), [MCP Roadmap](https://modelcontextprotocol.io/development/roadmap)).
* **Agent2Agent (A2A) Protocol Announced:** Google unveiled the Agent2Agent (A2A) protocol ([Google Developers Blog](https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/)), an open standard aiming to allow AI agents from different frameworks and vendors to communicate and collaborate. This is a significant step towards agent interoperability. Akshay Pachaar also provided a clear explanation contrasting [MCP vs. A2A](https://x.com/akshay_pachaar/status/1912123161883345321). ([GitHub Repo](https://github.com/google/A2A))
* **New MCP Tools:** Ishan Goswami released an open-source [Twitter MCP Tool using Exa](https://x.com/TheIshanGoswami/status/1914226695118168331) (GitHub: [exa-labs/exa-mcp-server](https://github.com/exa-labs/exa-mcp-server)) for searching tweets/profiles without the official API. Eyal Toledano shipped [TaskmasterAI v0.12](https://x.com/EyalToledano/status/1914084622918455572) with multi-PRD parsing, smarter breakdowns, and easier MCP setup, alongside a new [website](http://task-master.dev).
* **Cursor Workflows & Tips:** Ryo Lu shared [12 tips for using Cursor effectively](https://x.com/ryolu_/status/1914384195138511142), emphasizing clear rules, specific prompts, and iterative testing. Prajwal Tomar detailed his ["Context Boundary Method"](https://x.com/PrajwalTomar_/status/1913961327711633601) using structured docs (PRD, Flow, Tech Stack etc.) to guide AI coding tools like Cursor and reduce errors. Andrew Jefferson noted potential issues with [Markdown tab completion](https://x.com/EastlondonDev/status/1913967886521053688) in Cursor.
* **AI UI Builders Compared:** Damien shared a comparison of [Replit, Bolt.new, Lovable.dev, and v0](https://x.com/damienghader/status/1913248328302608482) for generating a multi-step onboarding flow from the same prompt.

## Building AI Agents: Frameworks & Best Practices

* **Agent Framework Discussion:** Harrison Chase (LangChain) published a deep dive on [how to think about agent frameworks](https://blog.langchain.dev/how-to-think-about-agent-frameworks/), sparking discussion comparing approaches (agents vs. workflows, declarative vs. non-declarative) and frameworks like LangGraph, OpenAI's Agents SDK, CrewAI, and AutoGen. Key themes include balancing flexibility vs. predictability and choosing the right abstraction level. OpenAI also released its own [practical guide to building agents](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf).
* **Production Agent Principles:** Dex Horthy shared principles for production-grade LLM apps in ["12-factor-Agents"](https://github.com/humanlayer/12-factor-agents), arguing successful systems often use focused LLM loops within well-engineered software rather than fully autonomous, monolithic agents. This resonated with many builders facing reliability challenges.
* **Agent Memory:** Taranjeet from [mem0.ai](https://x.com/taranjeetio/status/1912185506559053855) emphasized the importance of persistent memory (beyond session history) for truly intelligent agents that learn and adapt over time ([Blog Post](https://mem0.ai/blog/memory-in-agents-what-why-and-how/)).
* **Key Best Practices:** Common advice emerging from various discussions includes: start simple (maybe not even an agent), use structured outputs (like JSON schemas) to reduce hallucinations, prefer multiple specialized agents over one complex agent, own your control flow rather than relying solely on the framework, and carefully manage context windows. ([Anthropic Guide](https://www.anthropic.com/research/building-effective-agents), [Dev.to Summary](https://dev.to/isaachagoel/read-this-before-building-ai-agents-lessons-from-the-trenches-333i)).

___

**✨ Workshop Spotlight: Conquer the Complexity of Cursor ✨**

Master practical AI development workflows in Cursor. This hands-on workshop covers Agents, Ask, Custom Modes, multi-file analysis, effective prompting, Cursor rules, and strategies for handling AI failures.

* **When:** **This Thursday!** April 24, 2025, **9:00 AM - 2:00 PM (PDT)**
* **Where:** Zoom (Live Q&A included)
* **Investment:** $249

Unlock Cursor's potential and streamline your development process.

➡️ [**Read More about the Workshop**](https://egghead.io/workshop/cursor) ➡️ [**Register Now ($249)**](https://buy.stripe.com/9AQaG5ftF5P22eAfZ3)

_(Team training also available)_

___

## Notable Prompts

* **o3 Fact-Checking:** A prompt structure for using o3 to thoroughly fact-check an entire article by parsing individual facts. (See [Matt Shumer's Tweet](https://x.com/mattshumer_/status/1914412812891570199) for the prompt start).
* **Multiple Experts Method:** A system prompt that instructs the AI to analyze problems from multiple expert perspectives (e.g., Systems Thinker, Risk Assessor) and synthesize their insights. (See [God of Prompt's Tweet](https://x.com/godofprompt/status/1914370848032497906) for the full prompt and example).
* **Personality-Infused Prompt:** A detailed persona prompt instructing the AI to adopt a specific, informal, and slightly critical tone using modern slang and abbreviations. (See [Kitze's Tweet](https://x.com/thekitze/status/1913719205007937825) for the full prompt, originally from [@threepointone](https://x.com/threepointone)).

## Community Buzz & Resources

* **New Community Site:** [AGIdevice](https://x.com/agidevice/status/1913666033870647325) is building [cursorcommunity.com](http://cursorcommunity.com) in public.
* **Industry Chatter:** Deirdre Bosa discussed the potential [OpenAI bid for Windsurf](https://x.com/dee_bosa/status/1912906057791447294) and the shift towards the app layer. AI Native Dev reported on perceived [friction between Microsoft and Cursor](https://x.com/ainativedev/status/1912869556973949430) ([Article](http://ainativedev.co/spx)).
* **Android XR Demo:** Google showed off prototype smart glasses with Android XR ([Demo Video via 9to5Google](https://9to5google.com/2025/04/17/google-android-xr-smart-glasses-live-demo/)).
* **New Open Dialogue Model:** A new small open model, [Dia-1.6B](https://x.com/altryne/status/1914421817139454341), was released. It's focused on dialogue disentanglement – figuring out who's talking to whom in complex conversations. ([GitHub](https://github.com/nari-labs/dia), [Hugging Face](https://huggingface.co/nari-labs/Dia-1.6B)). I was extremely impressed with the demos – definitely worth checking out.
* **Video Generation with Veo 2:** Google's Veo 2 video generation model is now available in Gemini Advanced and Google AI Studio ([Google Blog](https://blog.google/products/gemini/video-generation/), [Developers Blog](https://developers.googleblog.com/en/veo-2-video-generation-now-generally-available/)). I've tried out a few videos and was really impressed with the quality. Pro tip: In AI Studio, you can use an image as a reference when generating video ([API Docs](https://ai.google.dev/gemini-api/docs/video#generate_from_images)), though surprisingly, Gemini doesn't support that yet. It's heavily rate-limited at the moment, but still fun to play with for generating short 8-second clips.

___

That’s the scoop for this issue! The pace isn't slowing down, particularly around agent capabilities, specialized models, and the tooling ecosystem supporting them.

If you have any feedback or questions, hit reply! Always happy to chat about the latest in AI dev tools.

John Lindquist


John Lindquist

AI Dev Essentials #3: Gemini Flash, o4-mini, Codex CLI, A2A Protocol & Agent Updates

AI Dev Essentials covers Gemini 2.5, O4-mini, Claude’s research tools, Codex CLI, and new workflows for building AI agents with MCP and Cursor.

Establish an automated, AI-driven workflow for implementing UI designs by comparing live development versions against target screenshots. This lesson integrates the Playwright MCP server for browser automation, a custom script using Pixelmatch for visual diffing, and Cursor Rules for persistent context. See how to instruct the Cursor Agent to iteratively implement design changes based on visual diff feedback, creating a robust loop where the AI refines the UI towards the target design.

**Workflow demonstrated in this lesson:**

*   Configure the Playwright MCP server within Cursor for browser control.
*   Use the Agent and Playwright MCP tools (`browser_navigate`, `browser_resize`, `browser_take_screenshot`) to capture baseline and current state PNG screenshots.
*   Install `pixelmatch` and `pngjs` dependencies.
*   Guide the Agent to create and run a TypeScript script (`compare-images.ts`) to generate visual diff images between screenshots.
*   Establish Cursor Rules (`visual-testing.mdc`, `project-setup.mdc`, etc.) to provide the Agent with necessary context about directories, scripts, dependencies, and the overall workflow.
*   Initiate an AI-driven design implementation loop:
    *   Agent captures the current state via Playwright.
    *   Agent runs the comparison script to get a visual diff.
    *   Agent analyzes the diff and implements code changes in the project (e.g., `app/page.tsx`, components, `globals.css`).
    *   Repeat the capture-compare-implement cycle, using the latest diff as feedback.
*   Use context files and prompts like "Please continue" to manage the multi-step process and guide the AI through potential interruptions.

**Key benefits:**

*   Creates an iterative, AI-driven workflow for implementing designs based on visual comparisons.
*   Combines browser automation (Playwright) and pixel-level diffing (Pixelmatch) within the Cursor environment.
*   Utilizes Cursor Rules to effectively manage context and guide the AI through complex, multi-step tasks.
*   Demonstrates how visual diffs can serve as direct feedback for AI-driven UI code generation and refinement.

AI-Driven Design Workflow: Playwright MCP Screenshots, Visual Diffs, and Cursor Rules

[Scraped MCP Examples](https://gist.github.com/johnlindquist/b19673bbf6a396406dff869beecace1d)
[ghx tool](https://www.npmjs.com/package/@johnlindquist/ghx)

Building complex components like Model Context Protocol (MCP) servers from scratch can be challenging, especially without good reference implementations. This lesson demonstrates a powerful workflow combining the `ghx` CLI tool with AI assistants (like Google's AI Studio and Cursor's agent) to overcome this hurdle.

You'll learn how to:

1.  **Use `ghx`:** Leverage the `ghx` command-line tool (which wraps the GitHub CLI) to search GitHub for real-world code examples based on specific import paths (e.g., `modelcontextprotocol/sdk/server/mcp.js`).
2.  **Refine Search Results:** Use `ghx` options (`--help`, `--limit`, `--max-filename`, `NOT demo`) within Cursor's chat to filter results, exclude simple demos, and gather a rich set of relevant MCP server implementations.
3.  **Provide AI Context:** Copy the aggregated code examples found by `ghx` into an AI environment like Google AI Studio (or ChatGPT).
4.  **Handle Context Limits:** See techniques for trimming large context files (like using Cursor's `Cmd+K` inline edit with `head -n` commands) to fit within model limits while retaining valuable examples.
5.  **Generate Code:** Prompt the AI (Gemini 2.5 Pro in AI Studio or ChatGPT O3) to generate a *new* MCP server (e.g., with five distinct tools) based *solely* on the provided real-world examples.
6.  **Integrate and Debug:** Set up the generated TypeScript code (`mcp_server.ts`) locally in Cursor, install dependencies (`pnpm install`), and use Cursor's agent (`Cmd+I`) or inline fixes (`Cmd+K`) to resolve TypeScript errors and path issues.
7.  **Configure in Cursor:** Add the newly created MCP server (running via `bun mcp_server.ts`) to Cursor's MCP settings, using the absolute path and the `bun` command.
8.  **Test the MCP Server:** Interact with Cursor's chat agent to call the custom tools (e.g., `add_note`, `list_notes`, `write_managed_file`) defined in the AI-generated MCP server, verifying its functionality.

This lesson showcases how combining targeted code searching (`ghx`) with the generative power of AI, fueled by relevant examples, can dramatically accelerate the process of building and bootstrapping complex tools and applications.

Generate and Debug MCP Servers from Scratch

Hey Everyone 👋,

John Lindquist here with the second issue of AI Dev Essentials! It's been another busy week in the AI tooling world. The biggest splash was probably GPT-4.1 hitting the streets, but there's plenty more action around MCP, Vercel's v0, Google's developer tools, and interesting community discussions. I've spent some time with GPT-4.1 already (specifically in Cursor), and while it shows promise, it didn't quite convince me to switch from Gemini 2.5 Pro yet. It stumbled on a few basic requests where Gemini usually shines on the first attempt.

---

### New egghead.io Lesson This Week:

* **[Create a Custom MCP that Calls Cursor Tools](https://egghead.io/create-a-custom-mcp-that-calls-cursor-tools~r77sw):** Learn how to build custom MCP server tools that allow Cursor's AI Agent to access your local project context. This lesson shows how to use Zod schemas and the crucial `.describe()` method to explicitly request information (like Git status or version) from the Cursor environment *before* your tool runs, enabling powerful, context-aware automation.

---

Here are the highlights that caught my eye this past week.

## Model Mania: GPT-4.1 Arrives, Plus Grok & Llama Updates

* **GPT-4.1 Lands:** OpenAI announced GPT-4.1, and it quickly became available via the [API](https://openai.com/live/) and showed up in [Cursor](https://x.com/cursor_ai/status/1911835651810738406). Cursor is offering it free for now to let users get a feel for it, though they don't recommend it as a default just yet. Curious to hear initial impressions from folks testing it out for coding tasks.

* **Grok 3 in Cursor:** Following other model additions, [Cursor also enabled Grok 3 models](https://x.com/amanrsanger/status/1910434915419906141), with the mini version available for free users. Aman Sanger noted it seems to "think upfront more than other models."

* **Community Hack: Llama 4.0 via Groq in Cursor:** Levi Dan shared a [detailed (and slightly hacky) guide](https://x.com/lxvi_brg/status/1908865544721154455) on how to wire up Groq's fast Llama 4.0 API into Cursor by using the OpenAI API key slot and intercepting requests. A clever workaround for the adventurous!

## Tooling & Platform Pulse

Lots of movement across different platforms and tools this week:

* **Vercel Ecosystem:**

  * Guillermo Rauch teased [v0 coming to VS Code](https://x.com/rauchg/status/1911524154458984515), hinting at tighter integration for the UI generation tool.

  * v0 also [added AI integrations](https://x.com/v0/status/1911912183149256943) with models from xai (Grok), FAL, Groq, and DeepInfra, including automatic API key setup and pay-as-you-go billing via Vercel Marketplace. They're offering a $10 credit for the Grok free tier.

  * Vercel shared insights on the [grep.app migration from CRA to Next.js](http://grep.app/), showcasing performance improvements. ([Source](https://x.com/rauchg/status/1911920410020757881)) I'm personally excited about this one – I rely heavily on examples when working with AI, and for me, a good example is often worth ten prompts. Tools like `grep.app` that make code discovery easier are invaluable.

* **Google's Growing Stack:**

  * Project IDX has officially become [Firebase Studio](https://x.com/_davideast/status/1909990728593453455), positioning itself as a cloud-based, agentic dev environment for full-stack AI apps, deeply integrated with Firebase. I've tried spinning up a few sites with it, and the speed is impressive. However, for more complex tasks like designing from images or intricate interactions, I still find myself leaning towards v0 for now.

  * Google quietly released the [Agent Development Kit (ADK)](https://x.com/omarsar0/status/1910004370864742757), a Python library (`pip install google-adk`) for building multi-agent systems with features like state management, tool usage, and orchestration. I haven't had a chance to dive into this yet, but it's right at the top of my list. Building robust agent systems is a huge area of interest, so this is probably the announcement I'm most excited about exploring this week.

  * Ramón Medrano Llamas shared his experience [moving back to VS Code from Cursor](https://x.com/rmedranollamas/status/1909516749612999149), highlighting the effectiveness of GitHub Copilot combined with the Gemini Code Assist extension (using Gemini 2.5 Pro in Agent Mode). I gave the Gemini Code Assist extension a try myself, but as someone deeply embedded in the Cursor workflow with established keyboard shortcuts and patterns, I struggled to find a flow I liked and didn't stick with it for long. It's interesting to see different perspectives, though!

  * AI features are rolling out more broadly in [Chrome](https://x.com/iam_chonchol/status/1909942954686636224), including text grabbing from YouTube videos and Google Lens integration.

* **Cloudflare Corner:**

  * Big news for edge compute: [Cloudflare Containers are coming to Open Beta in June](https://x.com/CherryJimbo/status/1910682562499850405), enabling running containerized apps (Next.js, Go, PHP confirmed) directly on the edge. This is huge news, in my opinion. Think about all the WordPress sites and other applications that rely on containerization. Opening this up on the edge unlocks incredible possibilities, including for AI applications. I'm super hyped to see what people build with this come June.

  * A new tool, [MCPify.ai](http://mcpify.ai/), launched for building MCP servers conversationally, built entirely on Cloudflare Workers and Durable Objects. ([Source](https://x.com/pbteja1998/status/1911723180445610149))

  * Securing MCP servers is getting easier, with examples shared using [WorkOS AuthKit](https://x.com/WorkOS/status/1910722639036874943) and [Auth0](https://x.com/dschenkelman/status/1910693265566728319).

* **IDE Updates:**

  * JetBrains shared the public [WebStorm roadmap for March-April](https://youtrack.jetbrains.com/issue/WEB-72310). ([Source](https://x.com/WebStormIDE/status/1909291367504748937))

> **✨ Workshop Spotlight: Conquer the Complexity of Cursor (Europe Friendly Time!) ✨**
>
> Missed the last workshop or found the timing tricky? This one's for you! Master practical AI development workflows in Cursor in a session scheduled for **12:00 PM UTC** to better accommodate European attendees.
>
> This hands-on workshop covers Agents, Ask, Custom Modes, multi-file analysis, effective prompting, Cursor rules, and strategies for handling AI failures. Unlock Cursor's potential and streamline your development process.
>
> * **When:** \[Check website for upcoming dates - This session is Europe-friendly at 12:00 PM UTC\]
>
> * **Where:** Zoom (Live Q&A included)
>
> * **Investment:** $149
>
> ➡️ [**Read More about the Workshop**](https://egghead.io/workshop/cursor)
> ➡️ [**Register Now ($149)**](https://buy.stripe.com/7sI7tT81dfpC06s28c)
>
> *(Team training also available)*

## Community Buzz & Resources

* **MCP Explained:** Kent C. Dodds wrote a piece explaining [why he's excited about Model Context Protocol (MCP)](https://www.epicai.pro/the-game-changing-potential-of-model-context-protocol) and its potential. ([Source](https://x.com/kentcdodds/status/1911840456432034112))

* **Prompting Guide:** Ian Nuttall surfaced [v7 of Google's Prompt Engineering Guide](https://x.com/iannuttall/status/1911086164196606314), a deep dive into techniques and best practices. Definitely worth a look.

* **Discussion Starter:** Eric Zakariasson asked the community about their [favorite CLIs and MCP servers to use with the Cursor agent](https://x.com/ericzakariasson/status/1910808935961088346). What are you all using?

* **Gemini 2.5 Pro Praise:** The positive buzz around Gemini 2.5 Pro continues to grow in the community. It's getting rave reviews and even achieving 'S-tier' status on social platforms like Reddit for its coding capabilities. ([Source](https://x.com/suchenzang/status/1911251230317490416))

That’s a wrap for this week! There's always so much happening, it's hard to keep up, but hopefully, this helps surface some of the more interesting bits for developers working with AI.

If you have any feedback or questions, feel free to respond to this email. Always happy to talk shop about the latest AI tools.

John Lindquist

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

AI Dev Essentials #2: GPT-4.1 Arrives, MCP Deep Dive & Google's Agent Dev Kit

AI Dev Essentials #2: GPT-4.1 & Gemini updates, MCP tools, Vercel v0, Google ADK, Cloudflare Containers news. Latest AI dev tooling highlights.

In this quick walkthrough, you’ll learn how to drop Nx into an existing npm or pnpm workspace and immediately benefit from project graph visualization, caching, and smart task orchestration, all without rewriting your setup.

You’ll start with a standard React monorepo containing a Vite app, a UI package, and utility functions. Then, using a single command (`nx init`), you’ll initialize Nx and see how it auto-detects your existing scripts, builds a dependency graph, and enables advanced features like affected commands and local caching.

We're also going to explore optional enhancements using Nx plugins for Vite and React. You’ll see how they help Nx infer tasks directly from your Vite config files, improve DX with the Nx Console VS Code extension, and leverage Nx plugin generators to scaffold code with a consistent structure.

What you’ll learn
- How to initialize Nx in an existing npm or pnpm monorepo
- How Nx understands your workspace structure and scripts
- How local caching and affected builds speed up development
- How optional Nx plugins improve DX without adding bloat
- How to scaffold new packages

Using Nx on an existing React and NPM workspace based monorepo

Applying Nx to an existing React monorepo to enable caching, task orchestration, and project graph analysis without changing your current setup.

Typing repetitive or complex instructions for Cursor's AI agent can slow down your workflow. This lesson teaches you how to create custom slash commands (e.g., `/s term`, `/l`, `/c`) using Cursor's "Rules" feature. Learn how to map these simple shortcuts to specific AI actions, instructing the agent to use precise tools like `codebase_search`, `edit_file`, or `run_terminal_cmd` based on your command and the current conversation context.

**Workflow demonstrated in this lesson:**

*   List available AI tools (built-in and MCP) to get their exact names.
*   Navigate to Cursor Settings -> Rules.
*   Define custom rules under a heading (e.g., `## Slash Commands`).
*   Create rules mapping a slash command pattern (like `/s <term>`) to a detailed instruction specifying which tool to use and how (e.g., "Use the codebase_search tool to search for <term/>").
*   Define rules that leverage conversation context (e.g., for summarizing notes or creating commit messages).
*   Save the rules (potentially in `.cursor/rules/project.mdc` for team sharing).
*   Invoke the custom slash commands (e.g., `/s handle`, `/l`, `/c`) in the chat/agent window.
*   Observe the AI understanding the shortcut and executing the intended tool call.

**Key benefits:**

*   Creates efficient, reusable shortcuts for common AI interactions.
*   Reduces the need for typing lengthy, detailed prompts repeatedly.
*   Allows mapping simple commands to specific Cursor tool invocations.
*   Enables commands that leverage the ongoing conversation context.
*   Improves workflow speed and consistency when working with the AI agent.

Speed Up Your Agents with Cursor Slash Commands

Hey Everyone 👋,

John Lindquist here. Since I've been diving deep into AI tooling and workflows over the past year, I'm starting this weekly newsletter to share updates on what interests me and could be helpful to the community. The goal is to help everyone stay up-to-date with the latest in essentials tools for AI devs.

I'll focus on relevant community news, model evaluations for coding, notable tools like Cursor and Windsurf, and practical workflows (including tools I build myself 😇). This week kicks off Cloudflare Developer Week with major announcements around agent/MCP services that many of us will likely use soon (I'll dig in and share my thoughts next issue). There are also lots of hints about new coding models possibly coming to Cursor (though my preference remains Gemini 2.5). Personally, I'm hoping for a Gemini Flash 2.5 variant. So let's hop into the latest! For my detailed, up-to-date workflows, check out the workshop info below.

Recent egghead.io lessons about AI tooling:

* **[Swarm Intelligence: Massively Parallelize Your AI Agents in Cursor](https://egghead.io/swarm-intelligence-massively-parallelize-your-ai-agents-in-cursor~g7u2g):** A workflow using `file-forge`, AI scripting, and a custom `git worktree` tool (`wt`) to launch parallel Cursor agents on different branches.
* **[Build a Better Edit Tool in Cursor with Custom Agent Modes](https://egghead.io/build-a-better-edit-tool-in-cursor-with-custom-agent-modes~21rr0):** Create a focused 'edit mode' in Cursor for precise AI refactors without conversational overhead, overcoming Command-K limitations.
* **[Visually Clone Websites with Gemini 2.5 Canvas for Cursor](https://egghead.io/visually-clone-websites-with-gemini-2-5-canvas-for-cursor~s5ugk):** Use Gemini 2.5 Pro's Canvas feature within Cursor to analyze and replicate website structures.

---

## Cloudflare Developer Week: Agent & Platform Updates

Cloudflare announced several updates relevant to AI application development:

* **Durable Objects Free Tier:** Lowers the barrier for experimenting with stateful serverless and the Agents SDK. ([Rita Kozlov](https://x.com/ritakozlov_/status/1909231625855983939))
* **MCP Enhancements:** BYO Auth (incl. [Auth0](https://x.com/auth0/status/1909307220816228354)) and Hibernation for MCP servers aim to improve agent security and efficiency. Exercise caution with MCP, but these are steps toward production viability.
* **Workflows GA & autoRAG:** Orchestration tool is now GA; a new autoRAG product indicates more integrated AI solutions.
* **Outerbase Acquisition:** Expect Durable Objects usability improvements following this acquisition. ([Rita Kozlov](https://x.com/ritakozlov_/status/1909232149246492887))
* **OpenNext Adapter Beta:** v1.0-beta for deploying Next.js apps on Cloudflare Pages adds caching, PPR, middleware support. ([CloudflareDev](https://x.com/CloudflareDev/status/1909598450871652398))

**Summary:** Cloudflare is actively enhancing its platform for AI/agent development, particularly reducing friction with Durable Objects and MCP.

## Llama 4 & Nemotron-Ultra Released

Meta's Llama 4 models began rolling out, with initial reports of variable quality across implementations. Meta attributes this to implementation stabilization, denying training on test sets ([Ahmad Al-Dahle](https://x.com/Ahmad_Al_Dahle/status/1909302532306092107)). Nvidia subsequently released **Llama-Nemotron-Ultra** (253B parameters), derived from Llama-405B via pruning and reasoning-focused post-training. Open weights and data are available ([Oleksii Kuchaiev](https://x.com/kuchaev/status/1909444566379573646)).

**Summary:** More powerful open models are available. Llama 4's initial rollout highlights the importance of stable implementations. Nemotron-Ultra adds a high-end specialized option.

---

## Quasar Alpha: Stealth Model on OpenRouter

OpenRouter provides early access to "Quasar Alpha," a model with limited public details but notable claims: 1M token context, benchmarks reportedly surpassing Claude 3.7 Sonnet, and >4x faster speeds. Reports suggest strong coding performance comparable to O3 Mini/DeepSeek R1 but significantly faster ([Matthew Berman's Thread](https://x.com/TheMattBerman/status/1908286423976886371)). The originating lab remains anonymous; speculation includes GPT-5, Claude 4, or Gemini 3.

**Summary:** The combination of large context, speed, and reported coding strength warrants attention for agentic workflows and large codebase analysis, despite benchmark caveats. Worth testing via OpenRouter if accessible.

---

**✨ Workshop Spotlight: Conquer the Complexity of Cursor ✨**

Master practical AI development workflows in Cursor. This hands-on workshop covers Agents, Ask, Custom Modes, multi-file analysis, effective prompting, Cursor rules, and strategies for handling AI failures.

* **When:** **This Thursday!** April 10, 2025, 9:00 AM - 2:00 PM (PDT)
* **Where:** Zoom (Live Q&A included)
* **Investment:** $149

Unlock Cursor's potential and streamline your development process.

➡️ [**Read More about the Workshop**](https://egghead.io/workshop/cursor)
➡️ [**Register Now ($149)**](https://buy.stripe.com/dR67tT4P17Xa8CYfZ1)

*(Team training also available)*

---

## Quick Links

* **Nightwhisper Buzz:** Highly-rated coding model "Nightwhisper" (rumored Gemini 2.5 variant?) left LMSys Arena; release may be imminent. ([ʟᴇɢɪᴛ Tweet](https://x.com/legit_api/status/1908264443827351913), [AiBattle Tweet](https://x.com/AiBattle_/status/1907519430961025476))
* **AI SDK Speech-to-Text:** Vercel AI SDK added a `transcribe` function. ([AI SDK Tweet](https://x.com/aisdk/status/1909603418639155460))
* **Gemini 2.5 Pro Updates:** Supports YouTube URLs as input in AI Studio (transcribe, summarize, analyze); reported improvements reducing stop issues/displaying thinking tokens. ([Jean Gatt Tweet](https://x.com/jean__gatt/status/1909256747518226829), [Eric Zakariasson Tweet](https://x.com/ericzakariasson/status/1908619515023548880))
* **Baby Cursor Project:** Cursor's Ryo Lu is building a rapid prototyping environment for IDE ideas. ([Ryo Lu Tweet](https://x.com/ryolu_/status/1908328050154233863))
* **(Rumor) Qwen3 Soon?:** Hints suggest Alibaba's Qwen3 model release is near. ([Elaina Tweet](https://x.com/Elaina43114880/status/1909572798944841859))

---

If you have any feedback or any questions, feel free to respond to this email. Always happy to talk shop about the latest AI tools.

John Lindquist

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

AI Dev Essentials #1: Cloudflare agent updates, Llama 4/Nemotron/Quasar models, Cursor workshop

Cursor's AI Agent has the abilitly to invoke MCP tools, but they lack direct access to your project. This lesson shows how to build custom MCP (Model Context Protocol) server tools that bridge this gap. Learn to define tool parameters using Zod schemas and the crucial `.describe()` method to explicitly request necessary context from the Cursor environment *before* your tool runs. See how the AI gathers this information (like Git status or version via terminal commands, or web search results) and passes it to your tool, enabling powerful, context-aware automation.

**Workflow demonstrated in this lesson:**

*   Scaffold a basic MCP server using a Cloudflare template (`pnpm create cloudflare`).
*   Run the MCP server locally and configure it in Cursor settings.
*   Define MCP tools (e.g., `status`) within the server code (`index.ts`).
*   Specify required context for tools using Zod schema parameters and `.describe()` (e.g., requesting "The status of the git repository").
*   Interact with the Cursor Agent using natural language (e.g., "Please check the status").
*   Observe the Agent's thought process: identifying the need for specific context based on the `.describe()` text.
*   See the Agent automatically using its *own* tools (like `run_terminal_cmd` or `web_search`) to gather the requested context *before* calling your MCP tool.
*   Watch the Agent call your MCP tool, passing the gathered local context (Git status, version, etc.) as arguments.
*   Receive the final response from the Agent, incorporating the information provided by your local MCP tool.

**Key benefits:**

*   Allows Cursor's AI to access and reason about information from your local machine (Git status, versions, file contents, etc.).
*   Enables the creation of AI tools that directly interact with or report on your local development environment.
*   Demonstrates the power of using `.describe()` in Zod schemas to guide the AI in gathering necessary context automatically.
*   Unlocks advanced automation possibilities by combining AI reasoning with local machine access.

Create a Custom MCP that Calls Cursor Tools

Vimium's Vomnibar is a "command palette"-like search tool for your open tabs, browser history, and bookmarks. We can search through and jump to any tab open across browser windows. We can also do a generalized search with results that also include browser history and bookmarks which can either be opened in the current tab or a new tab. If you're anything like me, you open tons of tabs and visit hundreds of webpages over the course of a week. The vomnibar puts all of that at your fingertips.

Josh Branchaud

Open Tabs, Browser History, and Bookmarks with the Vomnibar

Vimium's Vomnibar is a "command palette"-like search tool for your open tabs, browser history, and bookmarks.

Another aspect of Vimium's configurability is customizable key mappings. We can add new mappings and override existing ones. If there is a certain Vimium feature you want to make easier to trigger, adjust the key mapping to suit your needs.

Configure Custom Vimium Key Mappings

Another aspect of Vimium's configurability is customizable key mappings. We can add new mappings and override existing ones.

Colby Fayock

Create an eCommerce Store with Next.js and Stripe Checkout

Featured Coures

Search Results