Learn Scikit-learn, Strapi and Zag

**Developers aren’t the only ones working on sites.** 

Marketers, copywriters, designers, and other non-coding roles all need to be able to make content changes. If you don't want to be bothered to open a PR every time a typo needs fixed, you *need* a CMS. 

And Strapi is an *amazing* CMS option.  

Strapi helps you quickly build a robust content API. You can host it yourself, it supports both RESTful and GraphQL, handles your authentication, lets you bring team members and it's highly customizable with plugins and extensions. 

You can take those gains even further by adding **Next.js 13 to the stack.** 

Next.js is fast, supports both server and client-side rendering, and features dynamic routes. Once you are generating dynamic pages from your CMS you’ll see just how powerful the combination of Strapi and Next.js is!

**In this course you will do the following:** 

- Building Content Models with Strapi
- Fetching Data from your Headless CMS
- Using React Server Components
- Using the Next.js App directory
- Setting up pagination in Strapi and Next.js
- Parsing and rendering content in your Next.js application
- Connecting external services to your Headless CMS (like Cloudinary for Media Management)
- Deploying your Next.js and Strapi Applications to a production environment
- Setting up and using Strapi Plugins
Transferring data between your Strapi environments

By the end of this course you’ll be building pages and managing your content like a pro!

strapi

Modern CMS Driven Web Applications with Strapi and Next 13

There is a lot of extra functionality that you can import into your Strapi application through Strapi plugins. 

To demonstrate how easy this is, we'll install the `strapi-todo-plugin` and add a To-Do feature to our Strapi application that will help manage our content.

Install and Use a Strapi Plugin

Inviting users to your Strapi application is simple. First, we'll create a role for editors so they can't publish or delete content then we'll add the user and fill out name and email. This gives us a URL that we can send to the new collaborator and they can set their password and log in to the Strapi dashboard.

Invite a New User to Your Strapi App

When a new Strapi version is available, you'll see a notification in your admin panel. You can also check the [Strapi GitHub releases page](https://github.com/strapi/strapi/releases) that is linked in the notification to see what's new in the latest version and take note of the latest version number. 

Once we upgrade the Strapi dependencies and install again, you'll notice the notification is gone and when you check settings the version number has been updated. To update production, you push your changes to GitHub and run `git push heroku HEAD:main`.

Upgrade a Strapi App in Development and Production

There are times that when deploying your Strapi application you'll want the data and settings you developed with to be transferred to your production environment. To do this we can use Strapi's data transfer feature. 

To start the data transfer we will need to log into the production environment and create a transfer token. When the token is created we will just need to run `yarn strapi transfer --to :heroku-url` and paste the transfer token when prompted. You'll notice that all the data is present in your production enviroment as well as the roles you set up in development.

Transfer Data Between Environments with Strapi Data Transfer

Now that we've got a functioning application it's time to deploy. For Strapi, we'll use Heroku to deploy for production. To do so we will need to create a production environment file for `database.js` and `server.js`, then we log into Heroku and created a new app. Once logged in we will set all the environment variables in Heroku. Finally, we pushed our code to Heroku and saw our application running live on the web.

Deploy a Strapi Application to Heroku

cloudinary

We'll learn how to integrate Cloudinary into our Strapi application so that we can upload image assets in our Strapi dashboard and the resulting image will be stored in Cloudinary and ready for use in our application.

We'll create a `config/plugins.js` file and paste in some config code that sets Cloudinary as the provider with `cloud_name`, `api_key`, and `api_secret`.

Then we'll install the Cloudinary provider plugin with `npm install @strapi/provider-upload-cloudinary`, add the middleware security that lets us use Cloudinary, and finally add Cloudinary credentials to our `.env` file.

Install and Add the Cloudinary Provider to a Strapi Application

We'll cover the basics of building a new page in Next.js, specifically an "About Us" page. If you've used Next before, this will feel very similar to creating a new page in the `pages` directory. 

While doing this we will also be introduced to some of the components that come with the template, such as the `PageContainer`, `Main`, `Title`, and `Description` components which you can check out [in more detail here](https://github.com/malgamves/next-13-website-template/tree/main/components).


Create an About Us Page inside the Next.js 13 App Directory

GraphQL is a powerful technology that lets you query the exact data that you need when you need it on your front end. Strapi allows for GraphQL integration through a plugin.

You can install GraphQL with the following command:

```bash
yarn strapi install graphql
```
You'll notice this adds GraphQL in your plugins tab within Strapi. 

When that is installed you can navigate to `/graphql` in your Strapi project and query the data you have. 

Install and Query GraphQL API in Strapi

We have a problem right now in that if you were to try and fetch these posts from the API, you would get a 403 error. And that's because we haven't set up the end user permissions for the API to be able to access this content. So let's go ahead and do that now.

We'll modify the User permissions for the `Post` role and give public access to `find` and `findOne`.

Set up API End User Permissions to Make REST Queries in Strapi

The first thing we want to do is model the content that will be presented on our website. To do this we'll create a Post content type that will have several fields with types including text, rich text, date, and UID. 

After we create the content type you'll see how to manually create posts through the Strapi dashboard.

Create a Collection Type for a Post in Strapi

We'll start with the basics of creating a new Strapi project, naming the project API, and setting up the project to use an SQLite database.

Creating a New Strapi Project for Development with npx

Learn how to build a pin-input component with state machines, Zag.js and React.

We’ll look at modeling a UI component with state machines, implementing those in a framework agnostic way using Zag.js, and connect the logic to the UI component.

This course is a must-watch if you’re unfamiliar with State machines, and want to learn how to use them to build UI components with ease.

In this course, you will:

- Learn fundamental concept of state machine, event and transition
- Model a UI component with state machine
- Connect state machine logic to UI
- Manage DOM events in state machines
- Create custom React hooks with state machines

A collection of framework-agnostic UI component patterns like accordion, menu, and dialog that can be used to build design systems for React, Vue and Solid.js

Statechart Driven UI Components with Zag.js

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

In many projects, it is useful to separate the logic that you right with the view that you create so that you can easily share that logic throughout your application. In React we do this with custom React hooks.

We'll improve on the reusability of the pin input component by refactoring it to a custom React hook. To do this we will utilize the prop getter pattern 

This Headless Component pattern is a very useful pattern when building reusable components. It allows you separate functionality from presentation, making it easy to style them as needed.


Refactor Zag.js State Machine Powered Pin Component Functionality to a Custom React Hook

In some cases you'll want to actually have your pin input in a form to handle submitting the values. What's awesome about our implementation is that it doesn't get in the way of adding functionality like this.

First we'll extend our state machine to focus the first input when we click on the input label. Then we'll wrap our Pin Input component in a form element and implement an onSubmit. We can submit values of the form by creating a hidden input and set it's values to the joined values of the other inputs.


Submit Pin Input Values in a Form with a Hidden Input

When the pin input values are full we will want to do something with those values such as sending an HTTP request.

To do this we'll implement a callback in context that will get invoked when all the values are computed. We'll do this by creating a computed property that returns true when all values in context are full. From there we will watch that computed property to invoke our callback.

Trigger Side Effects using Zag.js computed and watch Properties

We have a bug in our pin input. Only 1 value should be allowed per input but if we focus an input that already has a value we can still input another value. 

Let's fix that.

We'll need to implement a function `getNextValue` that will take in the focused value of the current input and the event input that is coming in. After a set of conditionals we will select the value that wasn't the current focused value to update the field.


Implement Conditional Logic in a Zag.js Action to Enforce a Single Character Per Input

The paste event is a unique input event that we need to handle. When we paste a value in from the clipboard, we need to split that value and input single characters to the individual inputs in our Pin Input.

To do this we will need to `preventDefault` in the `onPaste` event so that we can implement our custom logic here. Next we'll implement `setPastedValue` that splits and iterates over the input value we receive and sets it into context. 

Finally we'll implement `focusLastEmptyInput` that looks up the index of the first empty value with `findIndex` and focuses that index.


Spread Values Across a Pin Input Field in a Zag.js State Machine 

We'll be implementing the backspace event which triggers two actions: `clearFocusedValue`, and `focusPreviousInput`. 

These implementations you'll be familiar with at this point but what you'll notice when we actually try to hit backspace that the focus value will get cleared but we won't be setting focus to the previous input. This is because there are several DOM mutations happening at the same time. We'll fix this by scheduling the focus of inputs to the next animation frame with `requestAnimationFrame`


Schedule Input Focus with requestAnimationFrame to Handle Multiple DOM Mutations in Zag.js

Let's actually implement inputting values into our Pin input. We have 3 functions that need implemented. They are `setFocusedValue`, `focusNextInput`, and `executeFocus`. The first two will be pretty straight forward in grabbing values from context and our events and setting new values to our context. 

When we finish implementing `setFocusedValue` and `setFocusedInput` we'll need a way to actually trigger our focus to be set in the DOM. This is where the watch property in a Zag.js State Machine comes into play. We will watch the `focusedIndex` context value and run `executeFocus` any time the focus index changes in our machine (e.g. when `focusNextInput` is triggered after an input event).


Trigger Side Effects in a Zag.js State Machine with the watch Property

Now that we have a machine and our UI is sending it events, we need to actually do something with events that are sent. This is where actions come into play.

We'll implement focus and blur events for the input by setting the context `focusedIndex` to the index that is coming in from the UI. We can mutate context directly in Zag.js because it handles mutations through proxies to stay reactive.


Implement a State Machine Action for Setting Input Focus in Zag.js

Writing clear and effective prompts or rules for AI (.mdc files in Cursor) can be tricky. Your instructions might start out clumsy or ambiguous, leading to less-than-ideal AI responses. This lesson demonstrates how to quickly refine them by referencing a dedicated "best practices" rule file directly within Cursor's inline editor (`Cmd+K`).

**Workflow demonstrated in this lesson:**

*   Select the text (a prompt or section of a rule) you want to improve.
*   Use `Cmd+K` to open the inline AI editor.
*   Reference your separate prompt best practices rule file using `@` (e.g., `@prompt-improve.mdc`).
*   Cursor's AI rewrites the selected text, applying the referenced best practices.
*   Accept the improved version (`Cmd+Enter`).
*   **(Bonus)** Use `Cmd+L` to send the edited section to the Agent chat and ask it to compare the changes with the previous version (using git history) and explain *why* the new version is better (e.g., improved clarity, stronger action verbs, explicit exclusions).

**Key benefits:**

*   Instantly improve prompt clarity and effectiveness based on your own defined standards stored in a rule file.
*   Reduces ambiguity in instructions, leading to better AI outcomes.
*   Leverages Cursor rules (`.mdc` files) as reusable templates for prompt refinement.
*   Provides insight into *how* and *why* prompts are improved via Agent comparison.

Stop wrestling with clunky prompts. Use this technique to systematically apply best practices and level up your AI instructions directly within Cursor.

```markdown
# Improve the User's Prompt Following the Patterns Below

> Practical prompt patterns to help anyone get clearer, more reliable answers from an AI agent.

| # | Pattern                       | Why It Matters                                                          | Template                                                                 | Example Prompt                                                                                             |
|---|-------------------------------|-------------------------------------------------------------------------|--------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------|
| 1 | Lead with the ask             | The model reads top-down; putting the goal first stops it wandering.    | `Do X. [context]`                                                        | "Summarize this PDF in 5 bullet points. The text is below: ..."                                            |
| 2 | Repeat the key ask at the end | Long contexts sometimes truncate; an end-cap protects you.              | `...[detail]... REMEMBER: Do X.`                                         | "List pros & cons, keep it balanced. REMEMBER: 5 pros, 5 cons."                                             |
| 3 | Specify output shape          | Dictating format cuts revision loops.                                   | `Return as: 1) short title, 2) table (CSV).`                             | "Give 3 holiday ideas. Format: destination, flight-time-hrs, avg cost."                                    |
| 4 | Use clear delimiters          | Backticks/headings/XML keep sections from blending.                     | `TEXT TO ANALYSE`                                                        | "Rate the style of the text between the fences."                                                            |
| 5 | Induce step-by-step thinking  | Planning first boosts multi-step accuracy.                              | `Think step-by-step then answer.`                                        | "Solve this puzzle. Think step-by-step before giving the final move."                                      |
| 6 | Ask it to plan its workflow   | For big jobs, AI outlines tasks before doing them.                      | `First draft a plan, wait, then execute.`                                | "We're writing an e-book. ❶ Outline chapters. ❷ Wait. ❸ When I say 'go', draft chapter 1."              |
| 7 | Limit or widen knowledge sources | Controls hallucination.                                               | `Use only the info below. / Combine basic knowledge + this context.`     | "Using only the product sheet below, write FAQs."                                                          |
| 8 | Guide information retrieval   | Helps AI pick the right docs before answering.                          | `List which docs look relevant, then answer.`                            | "30 sales memos attached. 1) Name the 5 most relevant. 2) Summarise their common points."                 |
| 9 | Show a style/example          | Anchors tone, length, vocabulary.                                       | `Match the style of: <example>`                                          | "Review this gadget in the style of the sample below: 'Short, witty, 3 key facts...'"                      |
| 10| Set correction handles        | One-line fixes let you steer quickly.                                   | `If length > 150 words, shorten.`                                        | "Describe blockchain to a child. If your answer is >150 words, cut it in half."                            |
| 11| Tell it when to stop or loop  | Prevents half-finished lists or runaway essays.                         | `Keep going until you list 20 ideas, then stop.`                         | "Brainstorm webinar titles. Give exactly 12, then finish."                                                  |
| 12| Request the hidden reasoning  | Good for audits; otherwise omit to keep it short.                       | `After the answer, include a brief reasoning section.`                   | "Which of these stocks looks over-valued? Answer first; add a 2-sentence rationale below a divider."        |
```

John Lindquist

Automatically Improve Cursor Rules Using Custom Prompts

Cursor's `Cmd+K` is fantastic for targeted code edits, but sometimes you need the AI to operate beyond the confines of your current selection—like extracting a piece of logic into a brand-new, top-level function. Standard `Cmd+K` often falls short, keeping changes localized. This lesson reveals how to overcome this limitation using Cursor's "Edit Full File" mode, turning complex refactoring of legacy code into a streamlined process.

**Workflow demonstrated in this lesson:**

*   Contrast the behavior of standard `Cmd+K` (Edit Selection) with the "Edit Full File" mode.
*   Use `Cmd+K`, then `Cmd+Shift+Enter` (or the dropdown) to invoke "Edit Full File" mode for broader AI refactoring.
*   Instruct the AI to extract selected code into new functions at the top level of the module.
*   Demonstrate breaking down a large, monolithic function into multiple smaller, exported, and testable functions.
*   Utilize the "Fix in Chat" feature (`Cmd+Shift+D`) to send error messages and surrounding code directly to an AI agent for quick resolution.

**Key benefits:**

*   **True Top-Level Extraction:** Move code out of its current scope and into new, independent functions anywhere in the file.
*   **Simplified Legacy Code Refactoring:** Easily break apart large, untestable functions into manageable, testable units.
*   **Improved Code Structure:** Quickly organize and modularize your codebase with AI assistance.
*   **Contextual Error Fixing:** Send errors and relevant code snippets to an AI agent via "Fix in Chat" for efficient debugging.

This lesson shows a powerful technique for serious refactoring in Cursor, especially when dealing with large or legacy codebases, making your functions more modular, testable, and maintainable.

Clean up Legacy Functions for Testability in Cursor (0.50+) with cmd+k

Hey Everyone 👋,  
  
John Lindquist here with the **fifth issue of AI Dev Essentials!** This week, I've been relying more on GPT-4.1 in Cursor (which seems vastly improved since I last tried it) when building CLI and node tools. GPT 4.1 seems more aggressive in using tools as a pseudo reasoning step, while Gemini 2.5 Pro often jumps straight to code changes based on its "real" reasoning. I'm finding that GPT 4.1 in Cursor is becoming legit, especially with a "please explain that back to me" workflow. The speed allows for almost instant alignment. This "time to alignment" is so critical. It's that moment you \*know\* the AI is on the same page after a brain dump. On another note, programming is getting weird! I had a moment working on an MCP process manager where all the code was correct, but my \*English descriptions\* of what it was doing were too technical and thus misleading. Wild times!  
  
Big news: **Gemini 2.5 Pro upgrade** launched a couple hours ago. I'm super excited for this to land in Cursor, hopefully even later today! For now, you can try it out in AI Studio. I can't wait to see the improvements in Cursor's agent mode, especially since the tool calling is reportedly vastly improved. Beyond that, the major themes this week include impressive new **generative AI capabilities** for voice, a continued surge in **developer tooling and frameworks** (especially open source), and ongoing discussions around **prompting best practices and AI model quirks.**  
  
Let's dive in!

* * *

🎓 New egghead.io Lessons This Week
-----------------------------------

*   [When to Use Cursor Rules Instead of MCPs](https://egghead.io/when-to-use-cursor-rules-instead-of-mcps~zazdq)
    
    This lesson demonstrates creating a Cursor Rule for a CLI tool (\`ghx\` for scraping GitHub examples) to make it available to the agent. It highlights how agent requested rules can be a simpler alternative to MCPs for tool integration, offering more control over context.
    
*   [Brainstorming and Planning with Mermaid Diagrams in Cursor](https://egghead.io/brainstorm-and-planning-with-mermaid-diagrams-in-cursor~9iu69)
    
    Learn to use Cursor Rules to enable Mermaid diagram generation. The lesson shows how to create and iterate on diagrams (like basic to do app flows and sequence diagrams for optimistic updates) visually within Cursor, providing a way to plan before coding.
    
*   [Create Complex Cursor Shortcuts to Run Commands and Generate AI Commits](https://egghead.io/create-complex-cursor-shortcuts-to-run-commands-and-generate-ai-commits~7arof)
    
    This lesson walks through setting up a custom keyboard shortcut (Command+Shift+S) in Cursor's JSON settings to run a sequence of commands: stage all git changes, use Cursor to generate a commit message, commit, and then push/pull.
    

* * *

💰 AI Coding Assistant Valuations & Acquisitions Skyrocket
----------------------------------------------------------

_The AI coding assistant space is on fire with some massive financial moves happening._

*   **Anysphere (Cursor IDE) Hits $9 Billion Valuation**
    
    Cursor's parent company, Anysphere, reportedly secured a new $900 million funding round, pushing its valuation to an estimated $9 billion. Key investors include Thrive Capital, Andreessen Horowitz (a16z), and Accel. This is a huge jump from their $2.5 billion valuation in January 2025, showing incredible investor confidence. (Source details from PitchBook: "Maker of AI-coding software Cursor is doubling its valuation every 8 weeks", citing The Financial Times; and Crunchbase News: "AI-Powered Coding Tool Anysphere Lands $900M At $9B — Report".)
    
*   **OpenAI Reportedly Acquires Windsurf (formerly Codeium) for ~$3 Billion**
    
    In what would be its largest acquisition, OpenAI is said to be acquiring Windsurf. Windsurf, an AI-assisted coding tool, was previously valued around $1.25 billion. This move clearly signals OpenAI's intent to bolster its position in the AI developer tools market. (Source details from Mashable citing Bloomberg: "OpenAI is buying Windsurf for $3 billion. What does that mean for ChatGPT?"; and Investing.com citing Reuters/Bloomberg: "OpenAI agrees to buy Windsurf for about $3 billion, Bloomberg News reports".)
    
    My take: It seems like OpenAI, above all, needed the team behind Windsurf. The value of people talented in code generation is through the roof right now. But they also needed a product ASAP, so it's essentially like they're paying for same day shipping, even with this incredible amount of money. And it boggles my mind that Cursor's valuation is estimated at $9 billion. I know a lot of us developers look at both Windsurf and Cursor and kind of think to ourselves that we could have forked VS Code and built these things. So, seeing an incomprehensible amount of value being assigned to what looks like something that we could build if we just would have dedicated our time to it is always pretty shocking.
    

* * *

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

🚀 Model & Platform Updates
---------------------------

_This week saw some impressive new releases and updates in the model space, particularly around generative capabilities for voice, alongside ongoing platform refinements._

*   **Gemini 2.5 Pro Upgrade: Now with Better Coding and Function Calling.**
    
    Google announced a significant upgrade to Gemini 2.5 Pro. It boasts improved performance in coding (especially frontend web dev, editing, and transformation) and more reliable function calling. The new model (\`gemini-2.5-pro-preview-05-06\`) automatically replaces the previous version with the same pricing and rate limits. [Details](https://developers.googleblog.com/en/gemini-2-5-pro-io-improved-coding-performance)
    
    This is the update I've been waiting for! Reliable tool/function calling is a massive unlock for agentic workflows. Eager to put this through its paces in Cursor.
    
*   **Minimax's High Ranking Text to Speech Models on Replicate.**
    
    Minimax's speech-02 models (speech-02-hd and speech-02-turbo) and voice cloning capabilities are now available on Replicate. They are touted as top ranking TTS models. [Replicate Blog](https://replicate.com/blog/minimax-text-to-speech)
    
*   **Gemini 2.0 Flash Photo Editing.**
    
    Google's Gemini 2.0 Flash is showcased for its ability to edit photos using natural language, without needing traditional tools like layers or brushes. (Mentioned by Rishabh, [Source](https://x.com/Rixhabh__/status/1919641187696418896))
    
*   **Grok 3.5 Beta Coming Soon.**
    
    Elon Musk announced that Grok 3.5 will have an early beta release next week for SuperGrok subscribers. He claims it can accurately answer technical questions by reasoning from first principles. ([Source](https://x.com/elonmusk/status/1917099777327829386))
    

🛠️ Developer Tooling, Frameworks & Ecosystem
---------------------------------------------

_The developer ecosystem continues to expand with new open source tools for data extraction, updates to agent frameworks, and interesting discussions on platform choices and best practices._

*   **ContextGem for Structured Data Extraction.**
    
    A new open source LLM framework, ContextGem, aims to simplify extracting structured data and insights from documents with minimal Python code. ([GitHub ContextGem](https://github.com/shcherbak-ai/contextgem) via Sumanth)
    
*   **Cloudflare Agents SDK Update: Upcoming Auth and State Handling.**
    
    An upcoming PR for the Cloudflare Agents SDK will enhance Agent classes to handle OAuth, redirect URLs, and reconnections out of the box. This makes every Agent an MCP client with state management. (Mentioned by Sunil Pai, [PR Link](https://github.com/cloudflare/agents/pull/254))
    
    Authorization has been one of the biggest challenges for MCPs, specifically because the MCP sits behind the AI agent. Most things are just configured in a simple JSON file defining your MCP servers. Triggering OAuth workflows inside UIs, which are essentially streaming text and working on other tasks, has been weird. Any sort of standardization and convenience they can add to authentication is very welcome, in my personal opinion.
    
*   **Persistent File Storage for Cloudflare Durable Objects Demo.**
    
    A demonstration of a real filesystem and terminal for Cloudflare Durable Objects using a Rust based chunked SQLite FUSE strategy ported to \`ctx.storage.sql\` and an xterm.js frontend. ([Demo](https://dofs.verifried.workers.dev/), [Tweet](https://x.com/benallfree/status/1919224851409379786))
    
    I love that as more new developers come on board, we can give them paradigms they're familiar with, like file systems and basic terminals to manipulate files. I think one of the biggest holdups for developers with things like images on their websites is they're just so unfamiliar with the various concepts around routing and where things are hosted. Any effort that brings existing paradigms that beginners understand to complex subjects is welcome, in my opinion.
    
*   **Stripe MCP Monetization.**
    
    Stripe now allows MCP developers to monetize their MCPs with subscriptions or usage based billing. It's compatible with various clients including Cloudflare's Agents SDK. ([Stripe MCP Payments](http://stri.pe/go/mcp-payments) via Jeff Weinstein)
    
    Stripe is obviously the biggest player in allowing people to spend money on things, so it's no surprise they're introducing ways to make money with MCPs. I'm definitely curious to see what sort of services will pop into existence now that you could request them from AIs. I'm in no hurry to pay for any MCP service myself, and I don't have any to recommend yet, but I'll definitely keep my eyes out for what may manifest from this.
    
*   **Cloudflare Workers Monorepo Template.**
    
    Jacob Hands shared a template for creating Workers monorepos. It's inspired by the \`mcp-server-cloudflare\` repo which deploys multiple Workers from one repo with shared packages. ([GitHub Template](http://github.com/jahands/workers-monorepo-template) via Jacob Hands)
    
*   **A Story of Migrating from Vercel to Cloudflare.**
    
    A developer shared their experience migrating their entire infrastructure to Cloudflare. They cited reasons related to control, security, performance, and pricing. ([Source](https://x.com/Osintly/status/1917964184198823951))
    
    I've seen a lot of people try to do this, especially with the perception that Next.js kind of locks you into Vercel. So I just think it's valuable for people to realize that options are out there and that a lot of your projects are more portable than you think they are.
    
*   **New MCP Authorization Spec.**
    
    A new MCP authorization spec has been introduced. It defines the MCP server as an OAuth "resource server" and outlines the authentication flow. Den Delimarsky provided a blog post with more details. ([Den Delimarsky's Blog](https://den.dev/blog/new-mcp-authorization-spec) via Yenkel)
    
    It'll be interesting to watch any of the MCP specs evolve over time. I know there's been a lot of work done with streaming. Authorization is obviously going to play a huge part. It'll be interesting to see all these pieces of MCPs fitting together and how all their auth will sync up, where the walls are built, and what they can and cannot do to communicate with each other. I can't imagine a system of roles and identifications for the various MCPs and how they allow each other to speak to one another is going to be critical for MCP moving forward.
    

💡 Prompting, Workflows & Best Practices
----------------------------------------

_This week brought fresh perspectives on interacting with LLMs, managing context, and structuring UI generation prompts._

*   **"AI Rivalry" Prompting Technique.**
    
    Greg Isenberg shared a technique of pitting different AI models (ChatGPT, Claude, Grok) against each other. You feed one's output to another with critical feedback to elicit better results. ([Source](https://x.com/gregisenberg/status/1918661279641723158))
    
    There's so much potential left to unlock when multiple models work with and against each other. It's still a little cost prohibitive to use this for a lot of the tools you're probably building by yourself. But I love any sort of back and forth or ping pong or even parallel agents coming to conclusions and fighting over what the best answers will be. I can only imagine what these techniques unlock. Hopefully someone will send me a credit card to run a bunch of experiments.
    
*   **Theo's Take on Major AI Models' Quirks.**
    
    Theo (t3.gg) shared a list of issues and frustrations with various AI models and providers including Gemini, Claude, ChatGPT, and Mistral. He covers setup, cost, and availability. ([Source](https://x.com/theo/status/1918810601968513249))
    
    I really agree with Theo's breakdown here. I've had a very similar experience trying out each of the models. So, definitely worth checking out his list. It's just a well written, very concise list.
    
*   **Tips for LLM Tools Editing Files with Diffs.**
    
    Matt Pocock initiated a discussion seeking examples and best practices for implementing LLM tools that edit files using diffs in TypeScript. ([Source](https://x.com/mattpocockuk/status/1918758488777408528))
    
    I hopped in on this discussion with Matt about my personal experience working with diffs. It's just so challenging to get LLMs to produce precise diff worthy code based on line numbers and white space, and then trying to match that up with the original file. It was a fascinating thread to read about how some people are solving the problem by using a second LLM trained specifically on diffing two files and essentially rewriting the entire file. It's a problem space I spent a lot of time in last year, but I'm just going to leave it up to all of these IDEs and tooling who are so far beyond where I got to now that it's not worth spending time on for myself.
    
*   **Prompting Guide for Lovable.dev for UI Generation.**
    
    Felix Haas shared a step by step guide on how to prompt Lovable.dev for better UI generation. It covers high level descriptions, look and feel, brand guidelines, UI library specification, and component details. ([Source](https://x.com/felixhhaas/status/1918316680108736775))
    
    I have some non developer friends using Lovable, and they seem to be really enjoying this, so I'm sending this over to them. This newsletter is more focused on a bit more experienced developers and what they would expect to read about, but this is definitely something I'm going to shoot over to a few people I know.
    
*   **Survey of AI Agent Protocols.**
    
    Elvis (omarsar0) highlighted key takeaways from a survey paper on AI Agent Protocols. He discussed the agent internet ecosystem, timelines, protocol overviews (MCP, A2A), evaluation considerations, and use case analyses. ([Source](https://x.com/omarsar0/status/1918723145923453022))
    
    I know that MCP gets so much attention, and it's interesting how it's taken over so quickly, but there are many other concepts to pay attention to, such as the A2A protocol. So it's definitely worth reading through how some of these things, when and why you would use different protocols.
    
*   **Vercel AI SDK \`useAssistant\` Hook.**
    
    Sam Denty pointed to the \`useAssistant\` hook in the Vercel AI SDK for building AI assistants. ([AI SDK Docs](https://ai-sdk.dev/docs/reference/ai-sdk-ui/use-assistant))
    
    The \`useAssistant\` hook was something I wasn't aware of, and Sam shared it with me. For an awesome hook for building out web based AI tools, I didn't know it existed, and I thought I'd pass it along because it covers a lot of scenarios that I would be building for web cases.
    

👨‍💻 X Posts from the Cursor Team
----------------------------------

_Folks from the Cursor team continue to share valuable insights and tips for getting the most out of the AI-first IDE._

*   **Effective Context Management in Cursor.**
    
    Eric Zakariasson (from the Cursor team) provided tips on managing context in Cursor. He emphasized the combination of intent and existing codebase state, using surgical @ mentions, rules for patterns, and MCP for external systems. ([Cursor Docs](https://docs.cursor.com/guides/working-with-context) via Eric Zakariasson)
    
*   **New Cursor Guide for Web Development.**
    
    Eric Zakariasson (from the Cursor team) also published a new guide for web development workflows in Cursor. ([Cursor Docs](https://docs.cursor.com/guides/tutorials/web-development))
    
*   **Cursor Rules for Better Results.**
    
    Ian (shaoruu) (from the Cursor team) shared examples of Cursor rules they use. These include specifying libraries, listing UI components, defining commands, and using "Auto Attach" for specific file contexts. ([Cursor Docs](https://docs.cursor.com/context/rules) via Ian)
    

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

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

**When:** Thursday, May 8, 2025, 9:00 AM to 2:00 PM (PDT)

**Where:** Zoom (Live Q&A included)

**Investment:** $249

[Read More](https://egghead.io/workshop/cursor) | [Register Now](https://buy.stripe.com/3csdSh2GTdhucTedQW)

_(Team training also available)_

That’s the scoop for this issue! As a final note, I'm excited for Google I/O in a couple of weeks. Since they're already releasing a huge update to my favorite model, and there are rumors around other models that are even better, I just can't wait to see what they have in store for us.  
  
If you have any feedback or questions, hit reply! Always happy to chat about the latest in AI dev tools.  
  
John Lindquist  
[egghead.io](https://egghead.io/)

AI Dev Essentials #5: 🤯 Cursor Valued at $9B, Gemini 2.5 Pro & More AI Updates

Want Cursor's AI Agent to intelligently run your custom CLI tools without complex MCP setups or constant hand-holding? If only the AI could understand your tool's `--help` output, life would be much simpler. This lesson demonstrates exactly that, leveraging Cursor's "Rules" feature with the "Agent Requested" type. You'll learn to feed your CLI's help text directly into a rule, effectively teaching the AI to operate your custom commands through natural language.

**Workflow demonstrated in this lesson:**

*   Execute your custom CLI tool's `--help` command (e.g., `ghx --help`) and pipe its output to your clipboard (e.g., `| pbcopy`).
*   Create a "New Cursor Rule" (Cmd/Ctrl + Shift + P, then "New Cursor Rule").
*   Paste the copied help text into the main content area of the rule.
*   Set the "Rule Type" to "Agent Requested".
*   Provide a clear, concise "Description" (e.g., "Search GitHub") that will act as the trigger phrase for the AI.
*   In an Agent chat, prompt the AI using natural language that corresponds to your rule's description (e.g., "Search GitHub for examples of package.jsons using semantic-release").
*   Observe as the Agent uses the rule's help text to correctly formulate and run your custom CLI command.
*   Leverage the tool's output by further instructing the AI to generate or modify project files (e.g., create a `package.json`, `.releaserc.json`, or `biome.json` based on findings).

**Key benefits:**

*   Empowers Cursor's AI Agent to directly use your existing custom CLI tools without needing to modify the tools themselves.
*   Simple and intuitive setup: Uses your tool's own documentation (`--help` output) as the "API" for the AI.
*   Efficient context usage: The detailed help text for your tool is only loaded into the AI's context when your specific trigger phrase is detected.
*   Provides a straightforward and powerful alternative to MCPs for many CLI tool integration scenarios, especially when tools already have good help messages.
*   Enables complex, natural language-driven automation by combining custom tool execution with the AI's code generation and modification capabilities.

By using "Agent Requested" rules, you gain maximum control over how and when the AI interacts with your custom tools, making the Agent a more versatile and powerful assistant tailored to your specific command-line utilities.

**Resources**

[https://www.npmjs.com/package/@johnlindquist/ghx](https://www.npmjs.com/package/@johnlindquist/ghx)



When to Use Cursor Rules Instead of MCPs

Planning complex application logic or workflows before coding can be challenging. This lesson demonstrates how to leverage Cursor's AI (Chat and Agent modes) to visually brainstorm and iterate on features by generating Mermaid diagrams directly within Markdown files. You'll learn how to use prompts to create flowcharts, sequence diagrams, explore edge cases, and improve the viewing experience for detailed diagrams.

**Workflow/Benefits Demonstrated in this lesson:**

*   Use Cursor AI (Chat/Agent) to generate Mermaid diagrams from natural language prompts.
*   Employ Markdown preview, popping it into a separate window for better viewing and zooming independent of the editor font size.
*   Iteratively refine diagrams by asking the AI to add features or create new diagram types (e.g., sequence diagrams).
*   Generate diagrams to visualize complex scenarios like optimistic updates and edge cases (conflict resolution, offline sync).
*   Create persistent visual artifacts (diagrams in Markdown) for planning, documentation, and guiding further AI development tasks.


## Mermaid Cursor Rules
````markdown
---
description: Whenever diagrams or mermaid is mentioned.
globs: 
alwaysApply: false
---
Here are the essential rules for creating Mermaid diagrams that render well in GitHub Markdown:

1.  **Use the Correct Fenced Code Block:**
    *   Always start the block with ```mermaid and end it with ```.
    *   ```markdown
        ```mermaid
          graph TD
            A[Start] --> B{Decision};
            B -- Yes --> C[Action 1];
            B -- No --> D[Action 2];
        ```
        ```

2.  **Stick to Well-Supported Diagram Types:**
    *   GitHub generally has good support for the most common types:
        *   `graph` (Flowcharts - `TD` is often best for readability)
        *   `sequenceDiagram`
        *   `classDiagram`
        *   `stateDiagram-v2` (Prefer v2 for better features/rendering)
        *   `erDiagram` (Entity Relationship)
        *   `pie` (Pie charts)
        *   `gantt` (Gantt charts)
        *   `mindmap` (Mind Maps - Basic structure only. *See syntax notes below*)
    *   Avoid extremely new or less common diagram types, as GitHub's Mermaid version might lag slightly behind the latest release.

3.  **Keep Syntax Simple and Standard:**
    *   **Node IDs:** Use simple alphanumeric IDs (e.g., `node1`, `processA`, `userAuth`). Avoid spaces or special characters in IDs.
    *   **Node/Actor/State Labels:** **Use quotes (`"..."`)** for labels, especially if they contain spaces, punctuation, special characters, or Mermaid keywords. This is the most common source of rendering errors.
        *   *Good:* `A["User Input"] --> B["Validate Data"];`
        *   *Bad (potential error):* `A[User Input] --> B[Validate Data];`
    *   **Arrows:** Use standard arrow types (`-->`, `---`, `==>`, `->>`, etc.).
    *   **Comments:** Use `%%` for comments if needed.

4.  **Mindmap Specifics for GitHub:**
    *   GitHub **supports the basic `mindmap` structure**, using indentation to define hierarchy (parent/child relationships).
    *   Ensure each node/item is on its **own line** with correct indentation relative to its parent.
    *   GitHub **DOES NOT support** experimental or advanced `mindmap` features like `::icon()` syntax. Using icons **will cause rendering errors**.
    *   Stick to plain text nodes for mind maps intended for GitHub Markdown.
    *   *Correct Example (GitHub compatible):*
        ```mermaid
        mindmap
          Root
            Parent
              Child 1
              Child 2
        ```
    *   *Incorrect Example (GitHub incompatible due to icons):*
        ```mermaid
        mindmap
          Root
            Parent
              ::icon(fa fa-one) Child 1
              ::icon(fa fa-two) Child 2
        ```

5.  **Prefer Vertical Layouts (`graph TD`):**
    *   For flowcharts (`graph`), `TD` (Top Down) or `TB` (Top Bottom) usually renders more readably within the flow of a Markdown document than `LR` (Left Right). GitHub often gives diagrams ample width, but vertical flows are easier to follow on typical screens.

6.  **Let GitHub Handle the Styling:**
    *   **DO NOT** try to set themes (e.g., `%%{init: {'theme': 'dark'}}%%`) or apply custom styling using `classDef` or `style` *within the Mermaid code*.
    *   GitHub **ignores** these theme directives and applies its own styling based on whether the user is viewing GitHub in light, dark, or dimmed mode. Your diagram will automatically adapt. Trying to force colors or themes will likely just be ignored or look out of place.

7.  **Keep Diagrams Focused:**
    *   Avoid overly complex diagrams with excessive nodes, edges, or nesting in a single block. While GitHub *can* render complex ones, they might become hard to read or hit rendering limits. Break down very complex ideas into multiple simpler diagrams if possible.

8.  **Test in GitHub Preview:**
    *   Always use GitHub's preview tab when editing your Markdown file to see exactly how the diagram will render. This is the best way to catch syntax errors or unexpected layout issues.

9.  **Tooling & Edit Verification Note:**
    *   Automated code editing tools may sometimes struggle to apply changes correctly within Mermaid blocks, especially with complex syntax involving indentation or specific formatting (like the mindmap example above).
    *   **Always carefully review edits** made to Mermaid blocks by automated tools. If errors persist or the diagram doesn't render as expected, manual correction might be necessary.

**In short:** Write standard, clearly quoted Mermaid syntax using common diagram types. For mindmaps in GitHub, use only the basic indentation structure (no icons). Prefer `graph TD`. Avoid trying to control the theme/colors yourself. Use the GitHub preview, and double-check automated edits to Mermaid blocks.
````

Brainstorm and Planning with Mermaid Diagrams in Cursor

Manually staging files, writing commit messages, committing, and syncing to Git involves multiple repetitive steps. This lesson demonstrates how to significantly streamline this common Git workflow in Cursor (or VS Code) by creating a single, powerful keyboard shortcut using `keybindings.json` and the `runCommands` feature.

**Workflow demonstrated in this lesson:**

*   Open `keybindings.json` to customize keyboard shortcuts.
*   Unbind default shortcuts (like `Shift+Cmd+S`) that you might not use.
*   Utilize the `runCommands` command to create a sequence of actions.
*   Chain together `git.stageAll`, `cursor.generateGitCommitMessage`, `git.commitAll`, and `git.sync` commands.
*   Bind this entire sequence to a single custom keyboard shortcut.
*   Execute the full stage -> AI commit message -> commit -> sync workflow with one keystroke.

**Key benefits:**

*   Combines multiple Git actions into one efficient step.
*   Automates staging, committing, and syncing changes.
*   Leverages Cursor's AI to generate commit messages automatically.
*   Frees up valuable keyboard shortcuts for powerful custom workflows.
*   Significantly speeds up your development cycle by reducing manual Git operations.

```json
  {
    "key": "shift+cmd+s",
    "command": "runCommands",
    "args": {
      "commands": [
        {
          "command": "git.stageAll"
        },
        {
          "command": "cursor.generateGitCommitMessage"
        },
        {
          "command": "git.commitAll"
        },
        {
          "command": "git.sync"
        }
      ]
    }
  },
  {
    "key": "shift+cmd+s",
    "command": "-workbench.action.files.saveAs"
  },
  {
    "key": "shift+cmd+s",
    "command": "-workbench.action.files.saveLocalFile",
    "when": "remoteFileDialogVisible"
  }
```

Create Complex Cursor Shortcuts to Run Commands and Generate AI Commits

In development we often want to test out features we are building but can only do so with deployed or staging applications or setting up Ngrok or Cloudflare Tunnels. 

UntunJS allows us to get the benefits of Cloudflare tunnels without having to go into the Cloudflare dashboard and set it up.

In this quick lesson we utilize UntunJS to run our local Nextjs application in a Cloudflare Tunnel

Ben Patton

Run local Nextjs App in a Cloudflare Tunnel with UntunJS

UntunJS is a great package to get the quickest start with Cloudflare tunnels and development and testing


Hey everyone 👋,  
  
John Lindquist here with the **fourth issue of AI Dev Essentials!** After months of teaching Cursor workshops, I've really enjoyed iterating on the AI assisted feedback loops: using AIs for spec work, diagramming, task management, and integrating them every step of the development process. I've even built a local MCP server that can monitor dev servers and test runners, checking on their progress to remove my biggest friction points when letting AI agents work autonomously. Expect an egghead.io lesson on it any day now. 🔧✨

🎓 New egghead.io Lesson
------------------------

[AI Driven Design Workflow: Playwright MCP, Screenshots, Visual Diffs & Cursor Rules](https://egghead.io/ai-driven-design-workflow-playwright-mcp-screenshots-visual-diffs-and-cursor-rules~aulxx)(egghead.io)

Walk through an automated loop where Cursor uses Playwright screenshots + Pixelmatch visual diffs to iteratively nudge your UI toward a target design.

🤖 Model Mania & Platform Shifts
--------------------------------

_The model landscape continues to shift rapidly, with major players releasing new contenders and tweaking existing ones based on user feedback and performance goals._

*   **OpenAI Rolls Back “Sycophantic” GPT 4o Update**
    
    OpenAI reverted last week’s GPT 4o tweak after users complained the model became an over eager yes man. The post explains how they detect and curb flattery bias. [Details](https://openai.com/index/sycophancy-in-gpt-4o/)(openai.com)
    
    It's fascinating when AI models get pushed so far by providers that public backlash forces a rollback to a previous state. This serves as a strong reminder that AI is software; it can be reverted, and users grow to expect predictability not just in information, but also in behavior and tone.
    
*   **Alibaba Unveils Open Weight _Qwen3_ Family**
    
    Eight new dense/MoE models (0.6B 235B) land with strong coding & math scores. The 235B flagship rivals closed source giants while staying fully open weight. [Benchmark blog](https://qwenlm.github.io/blog/qwen3/)(qwenlm.github.io)
    
    It's great to see more open source models being released. Personally, I tend to prefer the smartest models available for planning and coding tasks, and often lack the home hardware to run larger open models effectively. Still, these releases fuel hope for powerful on device models eventually rivaling giants like Gemini 2.5 Pro and O3.
    
*   **Gemini API Adds “Reasoning Effort” Knob**
    
    Google’s OpenAI compat endpoint now lets you pick _low → high_ reasoning, making it trivial to swap between Flash speed and deep thought. [Docs](https://ai.google.dev/gemini-api/docs/openai)(ai.google.dev)
    
    The distinction between questions needing quick answers versus deep thought is interesting. It's notable how AI models sometimes seem to first assess if a question requires deep thought before actually processing it, much like humans do. We instantly recall basic trivia but need to search our experiences for more complex answers.
    
*   **Rumor Mill: o3 pro Imminent?**
    
    Sam Altman mentioned an "o3 pro" tier a couple of weeks ago, fueling anticipation that a paid model between o3 and GPT 4o could drop any day now. Keep an eye on the pricing page. [Tweet](https://x.com/koltregaskes/status/1917143793649828320)(x.com)
    
*   **DeepSeek R2 Leak Hints at 1.2T Param Bargain LLM**
    
    Slides suggest a Huawei trained hybrid MoE vision model that’s 97% cheaper per token than GPT 4o, if the specs hold water, brace for price wars. [Leak thread](https://x.com/OpulentByte/status/1916195106580828344)(x.com)
    
    This lands squarely in the rumor mill and hasn't been confirmed. However, DeepSeek R1 was super impressive. If R2 lives up to these leaked specs, it has the potential to significantly disrupt the larger model landscape.
    

🛠️ Dev Tooling, Education & Ecosystem
--------------------------------------

_Beyond the models themselves, the surrounding ecosystem of tools, educational resources, and key personnel moves continues to evolve at pace._

*   **React Creator Jordan Walke Joins Replit**
    
    Walke says Replit’s AI first IDE feels like the early Facebook days and could onboard “the next billion programmers.” [Announcement](https://x.com/jordwalke/status/1915103101205594211)(x.com)
    
    I personally don't use full app generators like Replit, Lovable, or Bolt much, but I always keep a close eye on their announcements to see how far they push the tech. As an experienced developer, I haven't had much luck getting them to build apps where I don't know the final shape, but I can only imagine the feeling for a non programmer launching something from these tools. Definitely curious what the team will build next.
    
*   **Microsoft Drops “Generative AI for Beginners” Series**
    
    Free 18 episode curriculum covers LLM basics, responsible AI, and prompt craft, perfect onboarding material. [Watch](https://learn.microsoft.com/en-us/shows/generative-ai-for-beginners/)(learn.microsoft.com)
    
*   **OpenAI Launches Free “Academy” Courses**
    
    A new hub of AI courses, from intro to deep learning, built with universities like Georgia Tech, all 100% free. [Explore](http://academy.openai.com/)(academy.openai.com)
    
*   **GitHub Lists for Repo Curation**
    
    Use Lists to group related repos into smaller, AI friendly contexts, handy for prompting or onboarding. [Demo](https://x.com/janwilmake/status/1915338073061167487)(x.com) | [Example](https://github.com/janwilmake/forgithub.lists)(github.com)
    
    I didn't even know GitHub Lists was a feature! I'm definitely exploring ways to use AI to bring multiple repos together, since so many products are composed of different repositories. This looks like something fun to play with.
    
*   **Music AI Sandbox Upgrades (Lyria 2)**
    
    DeepMind’s tool now lets musicians generate, extend, and edit tracks with higher fidelity audio, all in browser. [Announcement](https://x.com/GoogleDeepMind/status/1915421048171856047)(x.com)
    
    Google getting into generative music tools for musicians is a welcome surprise. Their Veo 2 video generation is top tier, so you can only imagine the potential if they combine their music and video generation for ads and other media formats.
    
*   **Cloudflare Workers + Vercel AI SDK Starter**
    
    Kristian Freeman shared a template showing Gemini web search via the Vercel AI SDK in a Cloudflare Worker. [GitHub Repo](https://github.com/kristianfreeman/workers-vercel-ai-starter)(github.com)
    
    Adding web search to AI tooling significantly improves answers for many questions, especially in the fast moving dev space. I use deep research queries constantly in Gemini and OpenAI, so building easily launchable custom tools with web search enabled is something I'll definitely explore more soon.
    

🔌 Advancements in Agents & Protocols (MCP/A2A)
-----------------------------------------------

_The push towards more capable AI agents continues, with significant developments in the protocols and tools designed to help them interact with the world and each other._

*   **MCP Demo Day (Tomorrow!)**
    
    Cloudflare hosts demos from Atlassian, Intercom, Linear, PayPal, Sentry, Stripe, Webflow & more this Thursday (May 1st). [Details](https://demo-day.mcp.cloudflare.com/)(demo-day.mcp.cloudflare.com)
    
*   **Cloudflare Agents SDK Update**
    
    v0.0.66 includes a default MCP client, letting agents (and even MCP servers) call other MCP servers. [Details](https://x.com/threepointone/status/1915735083278880950)(x.com)
    
*   **\`mcp-memory\` Tool Released**
    
    An open source MCP server memory layer built on Cloudflare tech to share context between AI clients. [GitHub Repo](https://github.com/Puliczek/mcp-memory)(github.com)
    
*   **Zapier MCP Session (May 7th)**
    
    Learn best practices for leveraging Zapier's 7,000+ integrations via its MCP server in this free session. [Register](https://bit.ly/3XRrqfp)(bit.ly)
    
*   **Google: A2A + MCP Needed**
    
    Google reiterates that complex agentic apps likely need both A2A (agent to agent chat) and MCP (tool/data access). [Blog Post](https://goo.gle/4jSta0l)(goo.gle)
    
*   **Goose Agent Primer**
    
    A quick explainer on Block's Goose AI agent and how it uses MCP for task automation. [Project Site](https://block.github.io/goose)(block.github.io)
    
*   **Motia AI Agent Framework**
    
    Check out this open source framework with examples for deep research using OpenAI & Firecrawl. [Tweet](https://x.com/donvito/status/1915451174670749869)(x.com)
    

🚀 Level Up Your AI Dev Skills: Join My Cursor Workshop!
--------------------------------------------------------

Ready to master practical AI development workflows in Cursor? Join me, John Lindquist, for this hands on workshop! I've been teaching these sessions for months, refining the content, and I'm excited to share my latest insights on Agents, Ask mode, Custom Modes, multi file analysis, effective prompting, Cursor rules, and handling AI failures. Let's conquer the complexity together!

**When:** Thursday, May 8, 2025, 9:00 AM - 2:00 PM (PDT)

**Where:** Zoom (Live Q&A included)

**Investment:** $249

Act Fast! Get the Early Bird price of $200 if you register by midnight tonight (Wednesday, April 30th)!

[Read More](https://egghead.io/workshop/cursor)(egghead.io) | [Register Now ($200 Early Bird)](https://buy.stripe.com/3csdSh2GTdhucTedQW?prefilled_promo_code=SLV2PKOR)(buy.stripe.com)

_(Team training also available)_

⚡ Quick Links / Community Buzz
------------------------------

*   **Cursor Tips for Large Codebases:** Enable project structure, @ mention files, break down tasks, start new chats often, use Ask mode for planning. [Thread](https://x.com/ericzakariasson/status/1915072216523497628)(x.com)
    
    These tips come directly from the Cursor team themselves. Definitely worth reading through the thread if you work with large projects.
    
*   **Building Internal Tools w/ Cursor:** How Eric Zakariasson uses Cursor + Rules + MCP to build tools at Cursor. [Thread](https://x.com/ericzakariasson/status/1914696699274252405)(x.com)
    
    Another great thread from a Cursor employee detailing how they set up their internal configurations. Check this one out too!
    
*   **Gemma 3 OCR Demo:** A local OCR app powered by Google's Gemma 3. [GitHub Repo](https://github.com/patchy631/ai-engineering-hub/tree/main/gemma3-ocr)(github.com)
    
    I love seeing local models being used! Google is building AI directly into Chrome, and it's fascinating to watch how far they can push this. I often use OCR on screenshots for context in queries; the future of productivity might involve AIs constantly reading our screens. Faster OCR is better for all of us!
    
*   **Color Matcher Model:** Fix white balance or match colors for image model outputs. [Replicate](https://replicate.com/fofr/color-matcher)(replicate.com)
*   **o3 "Write in My Style" Prompt:** A two prompt technique for better voice cloning. [ShumerPrompt](https://shumerprompt.com/prompts/o3-write-in-my-style-prompt-017ae28e-c135-4f48-8bc5-8b78785a51d7)(shumerprompt.com)
*   **Open Source Prompt Library:** Conversational prompt templates for "vibe coding." [GitHub Repo](https://github.com/TechNomadCode/Open-Source-Prompt-Library/)(github.com)
*   **Kaggle 5 Day GenAI Course:** A quick intro to GenAI concepts. [Kaggle Learn](https://www.kaggle.com/learn-guide/5-day-genai)(kaggle.com)
*   **Underrated AI Coding Tools?:** Peter Yang asks the community for hidden gems. [Join the discussion](https://x.com/petergyang/status/1915934134507344095)(x.com)
*   **Value at the Application Layer:** Logan Kilpatrick on why now is a great time for builders (falling costs, rising intelligence & willingness to pay). [Clip](https://x.com/tbpn/status/1915110608149889385)(x.com)

That’s the scoop for this issue! The pace continues with new models, platform refinements, and a growing ecosystem of tools and educational resources aimed squarely at developers building with AI.  
  
If you have any feedback or questions, hit reply! Always happy to chat about the latest in AI dev tools.  
  
John Lindquist  
[egghead.io](https://egghead.io/)(egghead.io)

AI Dev Essentials #4: GPT-4o Rollback, Qwen3 Models, New AI Workflow Lesson & MCP Updates

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


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.

Search

Search Results