Learn Git, Rxjs and Script-kit

Next.js is a minimalistic framework for server-rendered React applications.

This project is a Next.js example of Kent C Dodd's Frontend Masters Advanced Remix Workshop project.

The aim of this project and course is to take a large project using the traditional Next.js pages architecture and migrate the full project to use the new app directory architecture.

We will fork project repo and clone it to get setup with the project locally. 

Fork and Clone the Next.js 13 Project to Get Started

How often do you avoid scripting something because it takes too much effort?\n\nScript Kit makes it easy to create and run scripts that solve your daily problems. Create a new script from the prompt then your script opens in the editor of your choice. Write a few lines of JavaScript. Then run the script from the prompt.\n\nSimply put, Script Kit helps you script away the friction of your day.

script-kit

Create, read, update, delete. Four actions that every developer becomes intimately familiar with over their career. Script Kit aims to make this process as pleasant as possible using a `db` helper and what better way to show it off than a Todos app?

You will also learn how to create and switch between tabs through Script Kit's `onTab` and `setTab` methods. 

[Install todos](https://scriptkit.com/api/new?name=todos&url=https://gist.githubusercontent.com/johnlindquist/3bdc967ffbd2f6d72491d07bf720f7e2/raw/a37b0058b502d6ba4bebd7a31a30be8789f5a146/todos.js")

```js
// Name: Todos

import "@johnlindquist/kit"

let { todos, write } = await db({ todos: [] })

onTab("Todos", async () => {
  while (true) {
    let todo = await arg("Toggle todo:", todos)
    let t = _.find(todos, todo)
    t.tag = t.tag === "open" ? "done" : "open"
    await write()
  }
})

onTab("New", async () => {
  let name = await arg("New todo:")
  todos.push({ name, id: uuid(), tag: "open" })
  await write()
  setTab("Todos")
})

onTab("Remove", async () => {
  let todo = await arg("Remove todo:", todos)
  _.remove(todos, todo)
  await write()
  setTab("Todos")
})
```


Build a Multi-Tab Todos App in Script Kit

When you want to collect news sources, airline ticket prices, or any events from sites that don't offer APIs, you can use scrapers to grab elements from off the page. 

Script Kit includes a `scrapeSelector()` helper that takes the URL you want to scrape and the selector you want from the page. Using the `// Schedule` metadata, you can also have this script run in the background on a Chron schedule and collect the data for you.


[Install scrape-tech-news](https://scriptkit.com/api/new?name=scrape-tech-news&url=https://gist.githubusercontent.com/johnlindquist/acd397a2ed487ef2a06c00d2951bed63/raw/3942107d2c92abc2c0317d15b0b3d025c5643ef0/scrape-tech-news.js")

```js
// Name: Scrape Tech News
// Schedule: 0 11 * * *

import "@johnlindquist/kit"

let h3s = await scrapeSelector(
  "https://news.google.com/topics/CAAqJggKIiBDQkFTRWdvSUwyMHZNRGRqTVhZU0FtVnVHZ0pWVXlnQVAB?hl=en-US&gl=US&ceid=US%3Aen",
  "h3"
)

let filePath = home("tech.md")
await ensureFile(filePath)
let contents =
  `

## ${new Date()}

` + h3s.map(h3 => `### ${h3}`).join("\n")
await appendFile(filePath, contents)
```

Scrape a Website on a Schedule with Script Kit

We put a lot of work into browsing the internet every day, it would be a pity to lose it all by closing all of our tabs. 

Script Kit can collect all of the tabs you currently have open in Chrome using its `getTabs` method and store them anywhere you want. 

This particular script converts the tabs to markdown links and stores them in a text file on your file system, but you could convert and store them using any approach you can think of.


[Install save-tabs](https://scriptkit.com/api/new?name=save-tabs&url=https://gist.githubusercontent.com/johnlindquist/4713a161a9ec48932b05436ba6a1a123/raw/33f753586d1a158dfb69d07f29850b6013d59f8b/save-tabs.js")

```js
// Name: Save Tabs

import "@johnlindquist/kit"

let tabs = await getTabs()

let tabsMd = tabs
  .map(tab => `* [${tab.title || tab.url}](${tab.url})`)
  .join("\n")

let notes = await editor(tabsMd)

let filePath = home("tab-notes.md")
await ensureFile(filePath)
await appendFile(filePath, notes)

edit(filePath)
```


Save Chrome Tabs in a Markdown File and Take Notes with Script Kit

Sometimes you just want to select and modify some text you have written somewhere on your system. To help you with this, Script Kit provides a `getSelectedText` and `setSelectedText`. Between these two helpers, your script and use and/or modify the text however you want. 

Applying an npm tool like `title-case` can help when you're not entirely sure when certain words need to be capitalized. In fact, I used the title case script on the title of this lesson!

[Install title-case](https://scriptkit.com/api/new?name=title-case&url=https://gist.githubusercontent.com/johnlindquist/0f8323d6aa599cfd62034351f9d38e8c/raw/625d0afd57ccbf8bf64c62bd135474cecf98c58b/title-case.js")

```js
// Name: Title Case

import "@johnlindquist/kit"

let { titleCase } = await npm("title-case")

let selectedText = await getSelectedText()
let titleText = titleCase(selectedText)

await setSelectedText(titleText)

// This Is the Title of My Next Blog Post
```


Apply Title Case to Text Anywhere Using Script Kit

Developers often keep their dev projects in a specific directory like "dev", "projects", or something similar. Script Kit allows you quickly read all the files of any directory then display them in a list so you can open them in your editor.


[Install open-project](https://scriptkit.com/api/new?name=open-project&url=https://gist.githubusercontent.com/johnlindquist/91cf994e450ecd5d45bce9aef9b345a1/raw/880be2d827b9602afe59d4e230e6753288f5bbb8/open-project.js")

```js
// Name: Open Project

import "@johnlindquist/kit"

let dirs = await readdir(home("dev"))

let selectedDir = await arg(
  "Open Project:",
  dirs.map(dir => ({
    name: dir,
    description: home("dev", dir),
    value: home("dev", dir),
  }))
)

edit(selectedDir)
```

List and Launch Dev Projects with Script Kit

We all have various tasks we need to accomplish with images. Whether it's resizing, optimizing, organizing, uploading, or anything else. Script Kit provides a `drop` component so you can simply drag and drop images into a script and process them in whatever way matches your workflow.


[Open drop-image in Script Kit](https://scriptkit.com/api/new?name=drop-image&url=https://gist.githubusercontent.com/johnlindquist/fe5b06f81cfea0d2dd94f743bc40ed15/raw/40a1b6ab271f7f664d7e54c4b779b056c6195b1c/drop-image.js")

```js
// Name: Drop Image

import "@johnlindquist/kit"

let files = await drop()
let imagePath = files[0].path

let Jimp = await npm("jimp")

let image = await Jimp.read(imagePath)
let newImagePath = path.resolve(
  path.dirname(imagePath),
  `new-${path.basename(imagePath)}`
)
await image
  .resize(parseInt(await arg("Width:"), 10), 100)
  .write(newImagePath)

```


Manipulate Images With Drag and Drop in Script Kit

Chrome allows developers to execute JavaScript using Apple Events. When you enable this feature, you can write scripts that can access and modify the page you're currently browsing. 

You can get the site's contents, update storage, or do any action you would typically do through an extension of the Chrome Dev Tools.

```jsx
let value = await applescript(`
tell application "Google Chrome" to tell window 1
	get execute active tab javascript "

${js}

"
end tell
`)
```

Control Chrome From Script Kit using Apple Events

Many developers use Chrome's Dev Tools as a playground for testing out data and JavaScript features. Script Kit enables you to launch Chrome Dev Tools instantly by simply using the `dev` method. Any data you pass into `dev` will show up in the console so you can inspect and play with the data in any way that you want.

[Install dev-tools-demo](https://scriptkit.com/api/new?name=dev-tools-demo&url=https://gist.githubusercontent.com/johnlindquist/6dcaf61e92819114c7478fefd24a71f8/raw/c2e69bfcff581f7929b881638627201b549d23f1/dev-tools-demo.js")

```js
// Name: Dev Tools Demo

import "@johnlindquist/kit"

let response = await get(
  `https://api.github.com/users/johnlindquist/repos`
)
dev(response.data)
```


Instantly Launch Chrome Dev Tools with Script Kit

This lesson walks through a script that can query a Hacker News API and display the information in Script Kit. 

Learn to do several things using Script Kit's global API methods, such as how to make and inspect data requests using `get` and `inspect`, how to display lists of data using `arg`, and how to display previews of the current selection.

[Install Hacker News Script](https://scriptkit.com/api/new?name=hackernews&url=https://gist.githubusercontent.com/johnlindquist/8728c8f56dd88951127810f0dea818d2/raw/8be4d28aa695f7842b610be258db7cd2e823a239/hackernews.js)

Write a Script with Script Kit to Browse Hacker News

Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

Getting started with contributing to open source projects can be very confusing and stressful. This talk will help clear away the confusion and pinpoint why and how you can make your first open source contribution. 



How to Make Your First Open Source Contribution

It always happens again. We have some weird bug in our codebase, hard to debug and just looking at the Git history doesn't help much. Git has a powerful command to help us: `git bisect`.

We have to simply identify a commit where the bug was not present, and the bad commit (usually the latest of the `master` or `main` branch). Then we invoke `git bisect` with both of them. The rest is just following along and answering questions. Let's see how that works.

Find that bad commit that broke your App with Git Bisect

You can create diffs in markdown to show what has changed in a code snippet. I use this in blog posts to highlight changed lines for readers. This works for code snippets in most markdown packages and on Dev.to.

To show a line of code changing in a function, you can do this:

```diff
function addTwoNumbers (num1, num2) {
-  return 1 + 2
+  return num1 + num2
}
```

First, instead of specifying the programming language, use diff after the backticks. Then at the beginning of any lines of code you want to show as removed, add a -. At the beginning of any lines of code you want to show as added, add a +.

The code would look like this:

````
```diff
function addTwoNumbers (num1, num2) {
-  return 1 + 2
+  return num1 + num2
}
```
````

Create a Diff in Markdown to Show What Has Changed in a Code Snippet

Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.

express

In this lesson, we will use Auth0 to generate a JWT that we can use to validate future requests to our server.

We will then return that token and test that it works when authenicated by our middleware.

During the lesson, we'll also briefly look at a strategy to keep your credentials out of source control using a .gitignore file. 

Get a JWT From Auth0 in Express to Be Used in Authentication

By default, git provides `master` as the default branch. This lesson shows how to get round that and use an alternative as the default branch.

The key is to switch to a new branch before you add your first commit, I choose `main` in this lesson. When I push `main` up to Github as the first branch, it gets set to the default.

Configure a New Github Repo to Use a Different Default Branch

By default, git provides `master` as the default branch. This lesson shows how to get round that and use an alternative as the default branch for an existing repo.

Configure an existing Github repo to use a different default branch

The magical disappearing UI framework

 - The web's JavaScript bloat crisis, solved. Svelte turns your templates into tiny, framework-less vanilla JavaScript.
 - Simple and familiar. Build apps out of composable, easy-to-write blocks using languages you already know.
 - Super fast, rock solid. Compile-time static analysis ensures the browser does no more work than it needs to.

svelte

Svelte can easily import RxJS and use all the Observables available fairly intuitively. Once you create your new Svelte project, simply install RxJS, create Observables as you would normally, then reference the Observable inside of your HTML with the `$` binding to subscribe to it.

This lesson walks you through the process of using an RxJS interval with Svelte by importing RxJS, then creating an interval Observable which we use inside of the template.

Use an RxJS Observable in Svelte

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

angular

One of the things that drove me crazy when I was first learning RxJS in Angular was how difficult it seemed to reload a collection of data after I added or deleted an item. With promises, I could just use `.then()` and be on my way. What do we do with observables? Should we just nest another subscription? Even if we do that, since we're using the async pipe, nothing will happen. There are better ways to handle this that are more reactive. In this lesson, I'm going to show you one way using Subjects. Subjects are kind of like event emitters that can have multiple listeners.

Refetching Data with Subjects in Angular

Using the [GitHub CLI](https://github.com/cli/cli) and a shell script, we will automate the process of monitoring pull requests in repositories we maintain. Specifically, open PRs we have created and those awaiting our review.

Monitor Pull Requests with the GitHub CLI

RxJS is a library for composing asynchronous and event-based programs by using observable sequences. 


rxjs

We will introduce our first requirement: showing a loading spinner immediately when tasks are going on in the background. We will then break this requirement into more and more specific english sentences, which we will later turn into actual observable stream.

Break down a requirement into small problems

The scan() is very useful in RxJS. It allows you to maintain a running state over time. In this lesson, we'll look at some of the state types scan can hold: transient or single source of truth, and how we can achieve each of them by combining it with the `share` operators.

We'll also look at the differences between `share() / shareReplay(1) / shareReplay({bufferSize: 1, refCount: true})` and how to avoid memory leaks when using them.

Maintain shared observable state using the scan and shareReplay operators

Learn how to create a simple MCP Server to search GitHub Issues.

I'll show you how to set up an MCP server tool, receive parameters, add the server to Cursor, and run it. We'll see how we can return a simple text response from the MCP server, as well as a markdown-formatted text containing clickable links.

Ákos Kőműves

Create a Simple GitHub Issue Search MCP Server using Cursor

Learn to build a simple MCP server to search GitHub issues and use it from Cursor.

Hey Everyone 👋,

John Lindquist here with the **sixth issue of AI Dev Essentials!** The AI coding landscape continues its rapid evolution, and this week is packed with significant updates. Cursor has rolled out its major 0.50 release, overhauling pricing, supercharging its AI features, and refining the developer experience. We're also seeing exciting new open-source entrants like the Zed code editor and the Cloudflare Agent Framework, plus fresh practical tips for your AI-assisted workflows. There's a lot to unpack, so let's dive in!

---

### New egghead.io Lessons This Week

* **[Clean up Legacy Functions for Testability in Cursor (0.50+) with cmd+k](https://egghead.io/clean-up-legacy-functions-for-testability-in-cursor-0-50-with-cmd-k~x1wb0)**

  Learn to refactor legacy code by extracting logic into new, top-level functions using Cursor's "Edit Full File" mode (Cmd+K then Cmd+Shift+Enter). This lesson shows how to break down monolithic functions into smaller, testable units and use "Fix in Chat" for quick error resolution, making your codebase more modular and maintainable.

* **[Automatically Improve Cursor Rules Using Custom Prompts](https://egghead.io/automatically-improve-cursor-rules-using-custom-prompts~5010d)**

  Refine unclear AI prompts or Cursor rules (.mdc files) by referencing a dedicated "best practices" rule file directly within Cmd+K. This lesson demonstrates how to instantly improve instruction clarity and leverage your own standards for better AI outcomes, with an option to have the AI Agent explain the improvements.


---

## 🚀 Cursor 0.50 Update: Key Enhancements
_Cursor's significant 0.50+ update simplifies pricing, boosts AI capabilities, and refines the developer experience. Highlights from their [changelog](https://www.cursor.com/changelog):_

### Simplified Pricing & Enhanced Model Access
Cursor introduces a unified, request-based pricing model. Max Mode, for demanding tasks, now offers token-based access to all top models. (*Note: Older Cursor versions will have access to previous MAX versions and long context mode for a few more weeks before they are sunset. [Read more about Max Mode](https://docs.cursor.com/max-mode).*)

### Advanced AI, Agentic Features & Broader Context
AI capabilities are enhanced with a new Tab Model for multi-file changes, a Background Agent (preview) for parallel tasks ([read more](https://docs.cursor.com/background-agent)), the ability to include the entire codebase in context using `@folders`, and fast agent-assisted edits in long files.

### Streamlined Workflow & Developer Experience
Developer workflow is streamlined with a refreshed Inline Edit (Cmd/Ctrl+K) integrated with agent options, support for multi-codebase projects via Workspaces, and improved chat features like markdown export and duplication.

---

## 🛠️ Dev Tooling, Frameworks & Ecosystem

_The developer ecosystem keeps expanding with new frameworks, SDKs, and practical agentic workflows._

* **Zed: The World's Fastest AI Code Editor**
  
  Zed is a new, open source, Rust-based code editor designed for agentic, collaborative editing. Features include automatic context discovery, real-time agent streaming, and extensibility via MCPs and tools. ([Zed](https://x.com/zeddotdev/status/1920102691365138826), [Blog](https://zed.dev/blog/fastest-ai-code-editor?x=60))

* **Cloudflare Agent Framework Video & Demo**
  
  Craig Dennis shows off the Cloudflare Agent Framework: synchronized agent state, client-side SQL storage, durable execution of third-party APIs (like YouTube), and human-in-the-loop RPC. [Watch the video](https://www.youtube.com/watch?v=ULu8hjFe_S0) | [GitHub](https://github.com/craigsdennis/kudos-agent) ([Craig Dennis](https://x.com/craigsdennis/status/1920643394872762487))

* **Mermaid Diagrams Coming to Cursor**
  
  The Cursor team announced that they will support Mermaid diagrams—great for visualizing complex code and data pipelines. ([ian](https://x.com/shaoruu/status/1922183290896744816))

* **AI SDK 5 Preview: UI Message Persistence**
  
  Store UI messages (not model messages) for better state restoration and backend integration (e.g., Langchain). ([Lars Grammel](https://x.com/lgrammel/status/1921542049821610068))

* **Gemini 2.5 Pro Turns YouTube Videos into Interactive Learning Apps**
  
  See it in action and check out [50+ free AI agent and RAG tutorials](https://github.com/Shubhamsaboo/awesome-llm-apps) ([Shubham Saboo](https://x.com/Saboo_Shubham_/status/1921210422742626449)).

---

## 💡 Prompting, Workflows & Best Practices

* **Prompting Techniques for Gemini Thinking Models**
  
  - Provide step-by-step instructions and refine as needed
  - Use multishot prompting for deeper understanding
  - Define output and behavior with clear system instructions
  - Debug and steer by checking reasoning for inconsistencies
  - For long outputs, be specific in your prompt
  [Full thread](https://x.com/googleaidevs/status/1922033670224806082) ([Google AI Developers](https://x.com/googleaidevs/status/1922033670224806082))

* **10 Brutal Lessons from 6 Months of Vibe Coding**
  
  [Reddit post](https://www.reddit.com/r/PromptEngineering/comments/1kk1i8z/10_brutal_lessons_from_6_months_of_vibe_coding/) ([Ian Nuttall](https://x.com/iannuttall/status/1921901239526109543))

* **Org Charts as Agent Architectures**
  
  Manu Cornet's classic comic is a surprisingly apt metaphor for AI agent architectures—even the Microsoft one. ([sunil pai](https://x.com/threepointone/status/1921105337907548350))

* **Pro Tip: Add Cursor's Docs to Cursor**
  
  Get Cursor tips inside Cursor by adding its own documentation. ([Fili](https://x.com/filiksyos/status/1920887960729170203))

* **Plan & Act Modes in Cline: Context-First Agentic Coding**
  
  Cline's Plan Mode helps you and the agent gather context and co-create a strategy before any code is written. Act Mode then executes with full context for robust, maintainable code. ([Cline](https://x.com/cline/status/1920009558971580648), [Blog](https://cline.bot/blog/plan-smarter-code-faster-clines-plan-act-is-the-paradigm-for-agentic-coding))

---

## 👨‍💻 Community Buzz & Quick Links

* **Anthropic is Thinking About a Meta Registry**
  
  [Discussion](https://github.com/modelcontextprotocol/registry/discussions/11) ([Sam Bhagwat](https://x.com/calcsam/status/1920250600412811314))

* **OpenAI Deep Research for GitHub Repos in ChatGPT**
  
  Connect GitHub repos to ChatGPT's deep research agent for detailed, cited reports. [Example](https://chatgpt.com/s/dr_681bf67f214c81918c0e9f934cd17171) ([OpenAI Developers](https://x.com/OpenAIDevs/status/1920556386083102844))

---

## ✨ 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 22, 2025, 9:00 AM to 2:00 PM (PDT)
* **Where:** Zoom (Live Q&A included)
* **Investment:** ~~$249~~ $200 (Early Bird - 20% off until May 14th at midnight!)

[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! The pace of change is only accelerating—new models, smarter agents, and better tools are landing every week. If you have feedback or questions, hit reply! Always happy to chat about the latest in AI dev tools.

John Lindquist

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

John Lindquist

AI Dev Essentials #6: Cursor 0.50, Zed, Cloudflare & AI Workflows

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

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

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)

Search

Search Results